diff --git a/src/cache.rs b/src/cache.rs
new file mode 100644
index 000000000..a8112794d
--- /dev/null
+++ b/src/cache.rs
@@ -0,0 +1,145 @@
+//! A cache for storing the results of layout computation
+use crate::geometry::Size;
+use crate::layout::{RunMode, SizeAndBaselines, SizingMode};
+use crate::style::AvailableSpace;
+
+/// The number of cache entries for each node in the tree
+pub(crate) const CACHE_SIZE: usize = 7;
+
+/// Cached intermediate layout results
+#[derive(Debug, Clone, Copy)]
+pub struct CacheEntry {
+    /// The initial cached size of the node itself
+    known_dimensions: Size<Option<f32>>,
+    /// The initial cached size of the parent's node
+    available_space: Size<AvailableSpace>,
+    /// Whether or not layout should be recomputed
+    run_mode: RunMode,
+
+    /// The cached size and baselines of the item
+    cached_size_and_baselines: SizeAndBaselines,
+}
+
+/// A cache for caching the results of a sizing a Grid Item or Flexbox Item
+pub struct Cache {
+    /// An array of entries in the cache
+    entries: [Option<CacheEntry>; CACHE_SIZE],
+}
+
+impl Cache {
+    /// Create a new empty cache
+    pub const fn new() -> Self {
+        Self { entries: [None; CACHE_SIZE] }
+    }
+
+    /// Return the cache slot to cache the current computed result in
+    ///
+    /// ## Caching Strategy
+    ///
+    /// We need multiple cache slots, because a node's size is often queried by it's parent multiple times in the course of the layout
+    /// process, and we don't want later results to clobber earlier ones.
+    ///
+    /// The two variables that we care about when determining cache slot are:
+    ///
+    ///   - How many "known_dimensions" are set. In the worst case, a node may be called first with neither dimensions known known_dimensions,
+    ///     then with one dimension known (either width of height - which doesn't matter for our purposes here), and then with both dimensions
+    ///     known.
+    ///   - Whether unknown dimensions are being sized under a min-content or a max-content available space constraint (definite available space
+    ///     shares a cache slot with max-content because a node will generally be sized under one or the other but not both).
+    ///
+    /// ## Cache slots:
+    ///
+    /// - Slot 0: Both known_dimensions were set
+    /// - Slot 1: 1 of 2 known_dimensions were set and the other dimension was either a MaxContent or Definite available space constraint
+    /// - Slot 2: 1 of 2 known_dimensions were set and the other dimension was a MinContent constraint
+    /// - Slot 3: Neither known_dimensions were set and we are sizing under a MaxContent or Definite available space constraint
+    /// - Slot 4: Neither known_dimensions were set and we are sizing under a MinContent constraint
+    #[inline]
+    fn compute_cache_slot(known_dimensions: Size<Option<f32>>, available_space: Size<AvailableSpace>) -> usize {
+        let has_known_width = known_dimensions.width.is_some();
+        let has_known_height = known_dimensions.height.is_some();
+
+        // Slot 0: Both known_dimensions were set
+        if has_known_width && has_known_height {
+            return 0;
+        }
+
+        // Slot 1: width but not height known_dimension was set and the other dimension was either a MaxContent or Definite available space constraint
+        // Slot 2: width but not height known_dimension was set and the other dimension was a MinContent constraint
+        if has_known_width && !has_known_height {
+            return 1 + (available_space.height == AvailableSpace::MinContent) as usize;
+        }
+
+        // Slot 3: height but not width known_dimension was set and the other dimension was either a MaxContent or Definite available space constraint
+        // Slot 4: height but not width known_dimension was set and the other dimension was a MinContent constraint
+        if !has_known_width && has_known_height {
+            return 3 + (available_space.width == AvailableSpace::MinContent) as usize;
+        }
+
+        // Slot 5: Neither known_dimensions were set and we are sizing under a MaxContent or Definite available space constraint
+        // Slot 6: Neither known_dimensions were set and we are sizing under a MinContent constraint
+        5 + (available_space.width == AvailableSpace::MinContent) as usize
+    }
+
+    /// Try to retrieve a cached result from the cache
+    #[inline]
+    pub fn get(
+        &self,
+        known_dimensions: Size<Option<f32>>,
+        available_space: Size<AvailableSpace>,
+        run_mode: RunMode,
+        sizing_mode: SizingMode,
+    ) -> Option<SizeAndBaselines> {
+        for entry in self.entries.iter().flatten() {
+            // Cached ComputeSize results are not valid if we are running in PerformLayout mode
+            if entry.run_mode == RunMode::ComputeSize && run_mode == RunMode::PeformLayout {
+                continue;
+            }
+
+            let cached_size = entry.cached_size_and_baselines.size;
+
+            if (known_dimensions.width == entry.known_dimensions.width
+                || known_dimensions.width == Some(cached_size.width))
+                && (known_dimensions.height == entry.known_dimensions.height
+                    || known_dimensions.height == Some(cached_size.height))
+                && (known_dimensions.width.is_some()
+                    || entry.available_space.width.is_roughly_equal(available_space.width)
+                    || (sizing_mode == SizingMode::ContentSize
+                        && available_space.width.is_definite()
+                        && available_space.width.unwrap() >= cached_size.width))
+                && (known_dimensions.height.is_some()
+                    || entry.available_space.height.is_roughly_equal(available_space.height)
+                    || (sizing_mode == SizingMode::ContentSize
+                        && available_space.height.is_definite()
+                        && available_space.height.unwrap() >= cached_size.height))
+            {
+                return Some(entry.cached_size_and_baselines);
+            }
+        }
+
+        None
+    }
+
+    /// Store a computed size in the cache
+    pub fn store(
+        &mut self,
+        known_dimensions: Size<Option<f32>>,
+        available_space: Size<AvailableSpace>,
+        run_mode: RunMode,
+        cached_size_and_baselines: SizeAndBaselines,
+    ) {
+        let cache_slot = Self::compute_cache_slot(known_dimensions, available_space);
+        self.entries[cache_slot] =
+            Some(CacheEntry { known_dimensions, available_space, run_mode, cached_size_and_baselines });
+    }
+
+    /// Clear all cache entries
+    pub fn clear(&mut self) {
+        self.entries = [None; CACHE_SIZE];
+    }
+
+    /// Returns true if all cache entries are None, else false
+    pub fn is_empty(&self) -> bool {
+        !self.entries.iter().any(|entry| entry.is_some())
+    }
+}
diff --git a/src/compute/flexbox.rs b/src/compute/flexbox.rs
index 6a2669a63..4c183d757 100644
--- a/src/compute/flexbox.rs
+++ b/src/compute/flexbox.rs
@@ -2,18 +2,17 @@
 use core::f32;
 
 use crate::compute::common::alignment::compute_alignment_offset;
-use crate::compute::{GenericAlgorithm, LayoutAlgorithm};
+use crate::compute::LayoutAlgorithm;
 use crate::geometry::{Point, Rect, Size};
 use crate::layout::{Layout, RunMode, SizeAndBaselines, SizingMode};
 use crate::math::MaybeMath;
-use crate::node::Node;
-use crate::prelude::{TaffyMaxContent, TaffyMinContent};
 use crate::resolve::{MaybeResolve, ResolveOrZero};
 use crate::style::{
     AlignContent, AlignItems, AlignSelf, AvailableSpace, Dimension, Display, FlexWrap, JustifyContent,
     LengthPercentageAuto, Position,
 };
 use crate::style::{FlexDirection, Style};
+use crate::style_helpers::{TaffyMaxContent, TaffyMinContent};
 use crate::sys::f32_max;
 use crate::sys::Vec;
 use crate::tree::LayoutTree;
@@ -22,37 +21,37 @@ use crate::tree::LayoutTree;
 use crate::debug::NODE_LOGGER;
 
 /// The public interface to Taffy's Flexbox algorithm implementation
-pub(crate) struct FlexboxAlgorithm;
+pub struct FlexboxAlgorithm;
 impl LayoutAlgorithm for FlexboxAlgorithm {
     const NAME: &'static str = "FLEXBOX";
 
+    #[inline(always)]
     fn perform_layout(
         tree: &mut impl LayoutTree,
-        node: Node,
         known_dimensions: Size<Option<f32>>,
         parent_size: Size<Option<f32>>,
         available_space: Size<AvailableSpace>,
         _sizing_mode: SizingMode,
     ) -> SizeAndBaselines {
-        compute(tree, node, known_dimensions, parent_size, available_space, RunMode::PeformLayout)
+        compute(tree, known_dimensions, parent_size, available_space, RunMode::PeformLayout)
     }
 
+    #[inline(always)]
     fn measure_size(
         tree: &mut impl LayoutTree,
-        node: Node,
         known_dimensions: Size<Option<f32>>,
         parent_size: Size<Option<f32>>,
         available_space: Size<AvailableSpace>,
         _sizing_mode: SizingMode,
     ) -> Size<f32> {
-        compute(tree, node, known_dimensions, parent_size, available_space, RunMode::ComputeSize).size
+        compute(tree, known_dimensions, parent_size, available_space, RunMode::ComputeSize).size
     }
 }
 
 /// The intermediate results of a flexbox calculation for a single item
-struct FlexItem {
+struct FlexItem<ChildId: Copy> {
     /// The identifier for the associated [`Node`](crate::node::Node)
-    node: Node,
+    node: ChildId,
 
     /// The base size of this item
     size: Size<Option<f32>>,
@@ -119,9 +118,9 @@ struct FlexItem {
 }
 
 /// A line of [`FlexItem`] used for intermediate computation
-struct FlexLine<'a> {
+struct FlexLine<'a, ChildId: Copy> {
     /// The slice of items to iterate over during computation of this line
-    items: &'a mut [FlexItem],
+    items: &'a mut [FlexItem<ChildId>],
     /// The dimensions of the cross-axis
     cross_size: f32,
     /// The relative offset of the cross-axis
@@ -168,13 +167,12 @@ struct AlgoConstants {
 /// Computes the layout of [`LayoutTree`] according to the flexbox algorithm
 pub fn compute(
     tree: &mut impl LayoutTree,
-    node: Node,
     known_dimensions: Size<Option<f32>>,
     parent_size: Size<Option<f32>>,
     available_space: Size<AvailableSpace>,
     run_mode: RunMode,
 ) -> SizeAndBaselines {
-    let style = tree.style(node);
+    let style = tree.style();
     let has_min_max_sizes = style.min_size.width.is_defined()
         || style.min_size.height.is_defined()
         || style.max_size.width.is_defined()
@@ -205,13 +203,12 @@ pub fn compute(
     if styled_based_known_dimensions.both_axis_defined() || !has_min_max_sizes {
         #[cfg(feature = "debug")]
         NODE_LOGGER.log("FLEX: single-pass");
-        compute_preliminary(tree, node, styled_based_known_dimensions, parent_size, available_space, run_mode)
+        compute_preliminary(tree, styled_based_known_dimensions, parent_size, available_space, run_mode)
     } else {
         #[cfg(feature = "debug")]
         NODE_LOGGER.log("FLEX: two-pass");
         let first_pass = compute_preliminary(
             tree,
-            node,
             styled_based_known_dimensions,
             parent_size,
             available_space,
@@ -223,7 +220,6 @@ pub fn compute(
 
         compute_preliminary(
             tree,
-            node,
             styled_based_known_dimensions
                 .zip_map(clamped_first_pass_size, |known, first_pass| known.or_else(|| first_pass.into())),
             parent_size,
@@ -236,14 +232,13 @@ pub fn compute(
 /// Compute a preliminary size for an item
 fn compute_preliminary(
     tree: &mut impl LayoutTree,
-    node: Node,
     known_dimensions: Size<Option<f32>>,
     parent_size: Size<Option<f32>>,
     available_space: Size<AvailableSpace>,
     run_mode: RunMode,
 ) -> SizeAndBaselines {
     // Define some general constants we will need for the remainder of the algorithm.
-    let mut constants = compute_constants(tree.style(node), known_dimensions, parent_size);
+    let mut constants = compute_constants(tree.style(), known_dimensions, parent_size);
 
     // 9. Flex Layout Algorithm
 
@@ -252,7 +247,7 @@ fn compute_preliminary(
     // 1. Generate anonymous flex items as described in §4 Flex Items.
     #[cfg(feature = "debug")]
     NODE_LOGGER.log("generate_anonymous_flex_items");
-    let mut flex_items = generate_anonymous_flex_items(tree, node, &constants);
+    let mut flex_items = generate_anonymous_flex_items(tree, &constants);
 
     // 9.2. Line Length Determination
 
@@ -283,7 +278,7 @@ fn compute_preliminary(
     // 5. Collect flex items into flex lines.
     #[cfg(feature = "debug")]
     NODE_LOGGER.log("collect_flex_lines");
-    let mut flex_lines = collect_flex_lines(tree, node, &constants, available_space, &mut flex_items);
+    let mut flex_lines = collect_flex_lines(tree, &constants, available_space, &mut flex_items);
 
     // If container size is undefined, determine the container's main size
     // and then re-resolve gaps based on newly determined size
@@ -299,7 +294,7 @@ fn compute_preliminary(
         constants.node_outer_size.set_main(constants.dir, Some(constants.container_size.main(constants.dir)));
 
         // Re-resolve percentage gaps
-        let style = tree.style(node);
+        let style = tree.style();
         let inner_container_size = constants.inner_container_size.main(constants.dir);
         let new_gap = style.gap.main(constants.dir).maybe_resolve(inner_container_size).unwrap_or(0.0);
         constants.gap.set_main(constants.dir, new_gap);
@@ -362,7 +357,7 @@ fn compute_preliminary(
     // 12. Distribute any remaining free space.
     #[cfg(feature = "debug")]
     NODE_LOGGER.log("distribute_remaining_free_space");
-    distribute_remaining_free_space(tree, &mut flex_lines, node, &constants);
+    distribute_remaining_free_space(tree, &mut flex_lines, &constants);
 
     // 9.6. Cross-Axis Alignment
 
@@ -385,33 +380,26 @@ fn compute_preliminary(
     // 16. Align all flex lines per align-content.
     #[cfg(feature = "debug")]
     NODE_LOGGER.log("align_flex_lines_per_align_content");
-    align_flex_lines_per_align_content(tree, &mut flex_lines, node, &constants, total_line_cross_size);
+    align_flex_lines_per_align_content(tree, &mut flex_lines, &constants, total_line_cross_size);
 
     // Do a final layout pass and gather the resulting layouts
     #[cfg(feature = "debug")]
     NODE_LOGGER.log("final_layout_pass");
-    final_layout_pass(tree, node, &mut flex_lines, &constants);
+    final_layout_pass(tree, &mut flex_lines, &constants);
 
     // Before returning we perform absolute layout on all absolutely positioned children
     #[cfg(feature = "debug")]
     NODE_LOGGER.log("perform_absolute_layout_on_absolute_children");
-    perform_absolute_layout_on_absolute_children(tree, node, &constants);
+    perform_absolute_layout_on_absolute_children(tree, &constants);
 
     #[cfg(feature = "debug")]
     NODE_LOGGER.log("hidden_layout");
-    let len = tree.child_count(node);
+    let len = tree.child_count();
     for order in 0..len {
-        let child = tree.child(node, order);
-        if tree.style(child).display == Display::None {
-            *tree.layout_mut(node) = Layout::with_order(order as u32);
-            GenericAlgorithm::measure_size(
-                tree,
-                child,
-                Size::NONE,
-                Size::NONE,
-                Size::MAX_CONTENT,
-                SizingMode::InherentSize,
-            );
+        let child = tree.child(order);
+        if tree.child_style(child).display == Display::None {
+            *tree.child_layout_mut(child) = Layout::with_order(order as u32);
+            tree.measure_child_size(child, Size::NONE, Size::NONE, Size::MAX_CONTENT, SizingMode::InherentSize);
         }
     }
 
@@ -490,15 +478,18 @@ fn compute_constants(
 ///
 /// - [**Generate anonymous flex items**](https://www.w3.org/TR/css-flexbox-1/#algo-anon-box) as described in [§4 Flex Items](https://www.w3.org/TR/css-flexbox-1/#flex-items).
 #[inline]
-fn generate_anonymous_flex_items(tree: &impl LayoutTree, node: Node, constants: &AlgoConstants) -> Vec<FlexItem> {
-    tree.children(node)
-        .map(|child| (child, tree.style(*child)))
+fn generate_anonymous_flex_items<Tree: LayoutTree>(
+    tree: &Tree,
+    constants: &AlgoConstants,
+) -> Vec<FlexItem<Tree::ChildId>> {
+    tree.children()
+        .map(|child| (child, tree.child_style(child)))
         .filter(|(_, style)| style.position != Position::Absolute)
         .filter(|(_, style)| style.display != Display::None)
         .map(|(child, child_style)| {
             let aspect_ratio = child_style.aspect_ratio;
             FlexItem {
-                node: *child,
+                node: child,
                 size: child_style.size.maybe_resolve(constants.node_inner_size).maybe_apply_aspect_ratio(aspect_ratio),
                 min_size: child_style
                     .min_size
@@ -601,14 +592,14 @@ fn determine_available_space(
 ///     Furthermore, the sizing calculations that floor the content box size at zero when applying box-sizing are also ignored.
 ///     (For example, an item with a specified size of zero, positive padding, and box-sizing: border-box will have an outer flex base size of zero—and hence a negative inner flex base size.)
 #[inline]
-fn determine_flex_base_size(
-    tree: &mut impl LayoutTree,
+fn determine_flex_base_size<Tree: LayoutTree>(
+    tree: &mut Tree,
     constants: &AlgoConstants,
     available_space: Size<AvailableSpace>,
-    flex_items: &mut Vec<FlexItem>,
+    flex_items: &mut Vec<FlexItem<Tree::ChildId>>,
 ) {
     for child in flex_items.iter_mut() {
-        let child_style = tree.style(child.node);
+        let child_style = tree.child_style(child.node);
 
         // A. If the item has a definite used flex basis, that’s the flex base size.
 
@@ -665,15 +656,15 @@ fn determine_flex_base_size(
             ckd
         };
 
-        child.flex_basis = GenericAlgorithm::measure_size(
-            tree,
-            child.node,
-            child_known_dimensions,
-            constants.node_inner_size,
-            available_space,
-            SizingMode::ContentSize,
-        )
-        .main(constants.dir);
+        child.flex_basis = tree
+            .measure_child_size(
+                child.node,
+                child_known_dimensions,
+                constants.node_inner_size,
+                available_space,
+                SizingMode::ContentSize,
+            )
+            .main(constants.dir);
     }
 
     // The hypothetical main size is the item’s flex base size clamped according to its
@@ -693,8 +684,7 @@ fn determine_flex_base_size(
             child.hypothetical_inner_size.main(constants.dir) + child.margin.main_axis_sum(constants.dir),
         );
 
-        let min_content_size = GenericAlgorithm::measure_size(
-            tree,
+        let min_content_size = tree.measure_child_size(
             child.node,
             Size::NONE,
             constants.node_inner_size,
@@ -727,14 +717,13 @@ fn determine_flex_base_size(
 ///
 ///         **Note that the "collect as many" line will collect zero-sized flex items onto the end of the previous line even if the last non-zero item exactly "filled up" the line**.
 #[inline]
-fn collect_flex_lines<'a>(
-    tree: &impl LayoutTree,
-    node: Node,
+fn collect_flex_lines<'a, Tree: LayoutTree>(
+    tree: &Tree,
     constants: &AlgoConstants,
     available_space: Size<AvailableSpace>,
-    flex_items: &'a mut Vec<FlexItem>,
-) -> Vec<FlexLine<'a>> {
-    if tree.style(node).flex_wrap == FlexWrap::NoWrap {
+    flex_items: &'a mut Vec<FlexItem<Tree::ChildId>>,
+) -> Vec<FlexLine<'a, Tree::ChildId>> {
+    if tree.style().flex_wrap == FlexWrap::NoWrap {
         vec![FlexLine { items: flex_items.as_mut_slice(), cross_size: 0.0, offset_cross: 0.0 }]
     } else {
         match available_space.main(constants.dir) {
@@ -788,10 +777,10 @@ fn collect_flex_lines<'a>(
 }
 
 /// Determine the container's main size (if not already known)
-fn determine_container_main_size(
-    tree: &mut impl LayoutTree,
+fn determine_container_main_size<Tree: LayoutTree>(
+    tree: &mut Tree,
     main_axis_available_space: AvailableSpace,
-    lines: &mut Vec<FlexLine<'_>>,
+    lines: &mut Vec<FlexLine<'_, Tree::ChildId>>,
     constants: &mut AlgoConstants,
 ) {
     let outer_main_size: f32 = constants.node_outer_size.main(constants.dir).unwrap_or_else(|| {
@@ -861,15 +850,15 @@ fn determine_container_main_size(
                             // min- or max- content contributuon
                             _ => {
                                 // Either the min- or max- content size depending on which constraint we are sizing under.
-                                let content_main_size = GenericAlgorithm::measure_size(
-                                    tree,
-                                    item.node,
-                                    Size::NONE,
-                                    constants.node_inner_size,
-                                    Size { width: main_axis_available_space, height: main_axis_available_space },
-                                    SizingMode::InherentSize,
-                                )
-                                .main(constants.dir)
+                                let content_main_size = tree
+                                    .measure_child_size(
+                                        item.node,
+                                        Size::NONE,
+                                        constants.node_inner_size,
+                                        Size { width: main_axis_available_space, height: main_axis_available_space },
+                                        SizingMode::InherentSize,
+                                    )
+                                    .main(constants.dir)
                                     + item.margin.main_axis_sum(constants.dir);
 
                                 // This is somewhat bizarre in that it's asymetrical depending whether the flex container is a column or a row.
@@ -965,9 +954,9 @@ fn determine_container_main_size(
 ///
 /// # [9.7. Resolving Flexible Lengths](https://www.w3.org/TR/css-flexbox-1/#resolve-flexible-lengths)
 #[inline]
-fn resolve_flexible_lengths(
-    tree: &mut impl LayoutTree,
-    line: &mut FlexLine,
+fn resolve_flexible_lengths<Tree: LayoutTree>(
+    tree: &mut Tree,
+    line: &mut FlexLine<Tree::ChildId>,
     constants: &AlgoConstants,
     original_gap: Size<f32>,
 ) {
@@ -996,7 +985,7 @@ fn resolve_flexible_lengths(
         let inner_target_size = child.hypothetical_inner_size.main(constants.dir);
         child.target_size.set_main(constants.dir, inner_target_size);
 
-        let child_style = tree.style(child.node);
+        let child_style = tree.child_style(child.node);
         if (child_style.flex_grow == 0.0 && child_style.flex_shrink == 0.0)
             || (growing && child.flex_basis > child.hypothetical_inner_size.main(constants.dir))
             || (shrinking && child.flex_basis < child.hypothetical_inner_size.main(constants.dir))
@@ -1049,11 +1038,12 @@ fn resolve_flexible_lengths(
                 })
                 .sum::<f32>();
 
-        let mut unfrozen: Vec<&mut FlexItem> = line.items.iter_mut().filter(|child| !child.frozen).collect();
+        let mut unfrozen: Vec<&mut FlexItem<Tree::ChildId>> =
+            line.items.iter_mut().filter(|child| !child.frozen).collect();
 
         let (sum_flex_grow, sum_flex_shrink): (f32, f32) =
             unfrozen.iter().fold((0.0, 0.0), |(flex_grow, flex_shrink), item| {
-                let style = tree.style(item.node);
+                let style = tree.child_style(item.node);
                 (flex_grow + style.flex_grow, flex_shrink + style.flex_shrink)
             });
 
@@ -1092,16 +1082,18 @@ fn resolve_flexible_lengths(
                 for child in &mut unfrozen {
                     child.target_size.set_main(
                         constants.dir,
-                        child.flex_basis + free_space * (tree.style(child.node).flex_grow / sum_flex_grow),
+                        child.flex_basis + free_space * (tree.child_style(child.node).flex_grow / sum_flex_grow),
                     );
                 }
             } else if shrinking && sum_flex_shrink > 0.0 {
-                let sum_scaled_shrink_factor: f32 =
-                    unfrozen.iter().map(|child| child.inner_flex_basis * tree.style(child.node).flex_shrink).sum();
+                let sum_scaled_shrink_factor: f32 = unfrozen
+                    .iter()
+                    .map(|child| child.inner_flex_basis * tree.child_style(child.node).flex_shrink)
+                    .sum();
 
                 if sum_scaled_shrink_factor > 0.0 {
                     for child in &mut unfrozen {
-                        let scaled_shrink_factor = child.inner_flex_basis * tree.style(child.node).flex_shrink;
+                        let scaled_shrink_factor = child.inner_flex_basis * tree.child_style(child.node).flex_shrink;
                         child.target_size.set_main(
                             constants.dir,
                             child.flex_basis + free_space * (scaled_shrink_factor / sum_scaled_shrink_factor),
@@ -1158,9 +1150,9 @@ fn resolve_flexible_lengths(
 /// - [**Determine the hypothetical cross size of each item**](https://www.w3.org/TR/css-flexbox-1/#algo-cross-item)
 ///     by performing layout with the used main size and the available space, treating auto as fit-content.
 #[inline]
-fn determine_hypothetical_cross_size(
-    tree: &mut impl LayoutTree,
-    line: &mut FlexLine,
+fn determine_hypothetical_cross_size<Tree: LayoutTree>(
+    tree: &mut Tree,
+    line: &mut FlexLine<Tree::ChildId>,
     constants: &AlgoConstants,
     available_space: Size<AvailableSpace>,
 ) {
@@ -1172,8 +1164,7 @@ fn determine_hypothetical_cross_size(
 
         child.hypothetical_inner_size.set_cross(
             constants.dir,
-            GenericAlgorithm::measure_size(
-                tree,
+            tree.measure_child_size(
                 child.node,
                 Size {
                     width: if constants.is_row { child.target_size.width.into() } else { child_cross },
@@ -1207,11 +1198,11 @@ fn determine_hypothetical_cross_size(
 
 /// Calculate the base lines of the children.
 #[inline]
-fn calculate_children_base_lines(
-    tree: &mut impl LayoutTree,
+fn calculate_children_base_lines<Tree: LayoutTree>(
+    tree: &mut Tree,
     node_size: Size<Option<f32>>,
     available_space: Size<AvailableSpace>,
-    flex_lines: &mut [FlexLine],
+    flex_lines: &mut [FlexLine<Tree::ChildId>],
     constants: &AlgoConstants,
 ) {
     // Only compute baselines for flex rows because we only support baseline alignment in the cross axis
@@ -1235,8 +1226,7 @@ fn calculate_children_base_lines(
                 continue;
             }
 
-            let measured_size_and_baselines = GenericAlgorithm::perform_layout(
-                tree,
+            let measured_size_and_baselines = tree.perform_child_layout(
                 child.node,
                 Size {
                     width: if constants.is_row {
@@ -1295,9 +1285,9 @@ fn calculate_children_base_lines(
 ///         If the flex container is single-line, then clamp the line’s cross-size to be within the container’s computed min and max cross sizes.
 ///         **Note that if CSS 2.1’s definition of min/max-width/height applied more generally, this behavior would fall out automatically**.
 #[inline]
-fn calculate_cross_size(
-    tree: &mut impl LayoutTree,
-    flex_lines: &mut [FlexLine],
+fn calculate_cross_size<Tree: LayoutTree>(
+    tree: &mut Tree,
+    flex_lines: &mut [FlexLine<Tree::ChildId>],
     node_size: Size<Option<f32>>,
     constants: &AlgoConstants,
 ) {
@@ -1332,7 +1322,7 @@ fn calculate_cross_size(
                 .items
                 .iter()
                 .map(|child| {
-                    let child_style = tree.style(child.node);
+                    let child_style = tree.child_style(child.node);
                     if child.align_self == AlignSelf::Baseline
                         && child_style.margin.cross_start(constants.dir) != LengthPercentageAuto::Auto
                         && child_style.margin.cross_end(constants.dir) != LengthPercentageAuto::Auto
@@ -1355,7 +1345,11 @@ fn calculate_cross_size(
 ///     and the sum of the flex lines' cross sizes is less than the flex container’s inner cross size,
 ///     increase the cross size of each flex line by equal amounts such that the sum of their cross sizes exactly equals the flex container’s inner cross size.
 #[inline]
-fn handle_align_content_stretch(flex_lines: &mut [FlexLine], node_size: Size<Option<f32>>, constants: &AlgoConstants) {
+fn handle_align_content_stretch<ChildId: Copy>(
+    flex_lines: &mut [FlexLine<ChildId>],
+    node_size: Size<Option<f32>>,
+    constants: &AlgoConstants,
+) {
     if constants.align_content == AlignContent::Stretch && node_size.cross(constants.dir).is_some() {
         let total_cross_axis_gap = sum_axis_gaps(constants.gap.cross(constants.dir), flex_lines.len());
         let total_cross: f32 = flex_lines.iter().map(|line| line.cross_size).sum::<f32>() + total_cross_axis_gap;
@@ -1383,12 +1377,16 @@ fn handle_align_content_stretch(flex_lines: &mut [FlexLine], node_size: Size<Opt
 ///
 ///     **Note that this step does not affect the main size of the flex item, even if it has an intrinsic aspect ratio**.
 #[inline]
-fn determine_used_cross_size(tree: &mut impl LayoutTree, flex_lines: &mut [FlexLine], constants: &AlgoConstants) {
+fn determine_used_cross_size<Tree: LayoutTree>(
+    tree: &mut Tree,
+    flex_lines: &mut [FlexLine<Tree::ChildId>],
+    constants: &AlgoConstants,
+) {
     for line in flex_lines {
         let line_cross_size = line.cross_size;
 
         for child in line.items.iter_mut() {
-            let child_style = tree.style(child.node);
+            let child_style = tree.child_style(child.node);
             child.target_size.set_cross(
                 constants.dir,
                 if child.align_self == AlignSelf::Stretch
@@ -1429,10 +1427,9 @@ fn determine_used_cross_size(tree: &mut impl LayoutTree, flex_lines: &mut [FlexL
 ///
 ///     2. Align the items along the main-axis per `justify-content`.
 #[inline]
-fn distribute_remaining_free_space(
-    tree: &mut impl LayoutTree,
-    flex_lines: &mut [FlexLine],
-    node: Node,
+fn distribute_remaining_free_space<Tree: LayoutTree>(
+    tree: &mut Tree,
+    flex_lines: &mut [FlexLine<Tree::ChildId>],
     constants: &AlgoConstants,
 ) {
     for line in flex_lines {
@@ -1443,7 +1440,7 @@ fn distribute_remaining_free_space(
         let mut num_auto_margins = 0;
 
         for child in line.items.iter_mut() {
-            let child_style = tree.style(child.node);
+            let child_style = tree.child_style(child.node);
             if child_style.margin.main_start(constants.dir) == LengthPercentageAuto::Auto {
                 num_auto_margins += 1;
             }
@@ -1456,7 +1453,7 @@ fn distribute_remaining_free_space(
             let margin = free_space / num_auto_margins as f32;
 
             for child in line.items.iter_mut() {
-                let child_style = tree.style(child.node);
+                let child_style = tree.child_style(child.node);
                 if child_style.margin.main_start(constants.dir) == LengthPercentageAuto::Auto {
                     if constants.is_row {
                         child.margin.left = margin;
@@ -1477,9 +1474,9 @@ fn distribute_remaining_free_space(
             let layout_reverse = constants.dir.is_reverse();
             let gap = constants.gap.main(constants.dir);
             let justify_content_mode: JustifyContent =
-                tree.style(node).justify_content.unwrap_or(JustifyContent::FlexStart);
+                tree.style().justify_content.unwrap_or(JustifyContent::FlexStart);
 
-            let justify_item = |(i, child): (usize, &mut FlexItem)| {
+            let justify_item = |(i, child): (usize, &mut FlexItem<Tree::ChildId>)| {
                 child.offset_main =
                     compute_alignment_offset(free_space, num_items, gap, justify_content_mode, layout_reverse, i == 0);
             };
@@ -1506,14 +1503,18 @@ fn distribute_remaining_free_space(
 ///     - Otherwise, if the block-start or inline-start margin (whichever is in the cross axis) is auto, set it to zero.
 ///         Set the opposite margin so that the outer cross size of the item equals the cross size of its flex line.
 #[inline]
-fn resolve_cross_axis_auto_margins(tree: &mut impl LayoutTree, flex_lines: &mut [FlexLine], constants: &AlgoConstants) {
+fn resolve_cross_axis_auto_margins<Tree: LayoutTree>(
+    tree: &mut Tree,
+    flex_lines: &mut [FlexLine<Tree::ChildId>],
+    constants: &AlgoConstants,
+) {
     for line in flex_lines {
         let line_cross_size = line.cross_size;
         let max_baseline: f32 = line.items.iter_mut().map(|child| child.baseline).fold(0.0, |acc, x| acc.max(x));
 
         for child in line.items.iter_mut() {
             let free_space = line_cross_size - child.outer_target_size.cross(constants.dir);
-            let child_style = tree.style(child.node);
+            let child_style = tree.child_style(child.node);
 
             if child_style.margin.cross_start(constants.dir) == LengthPercentageAuto::Auto
                 && child_style.margin.cross_end(constants.dir) == LengthPercentageAuto::Auto
@@ -1552,8 +1553,8 @@ fn resolve_cross_axis_auto_margins(tree: &mut impl LayoutTree, flex_lines: &mut
 /// - [**Align all flex items along the cross-axis**](https://www.w3.org/TR/css-flexbox-1/#algo-cross-align) per `align-self`,
 ///     if neither of the item's cross-axis margins are `auto`.
 #[inline]
-fn align_flex_items_along_cross_axis(
-    child: &mut FlexItem,
+fn align_flex_items_along_cross_axis<ChildId: Copy>(
+    child: &mut FlexItem<ChildId>,
     free_space: f32,
     max_baseline: f32,
     constants: &AlgoConstants,
@@ -1610,8 +1611,8 @@ fn align_flex_items_along_cross_axis(
 ///     - Otherwise, use the sum of the flex lines' cross sizes, clamped by the used min and max cross sizes of the flex container.
 #[inline]
 #[must_use]
-fn determine_container_cross_size(
-    flex_lines: &mut [FlexLine],
+fn determine_container_cross_size<ChildId: Copy>(
+    flex_lines: &mut [FlexLine<ChildId>],
     node_size: Size<Option<f32>>,
     constants: &mut AlgoConstants,
 ) -> f32 {
@@ -1639,20 +1640,19 @@ fn determine_container_cross_size(
 ///
 /// - [**Align all flex lines**](https://www.w3.org/TR/css-flexbox-1/#algo-line-align) per `align-content`.
 #[inline]
-fn align_flex_lines_per_align_content(
-    tree: &impl LayoutTree,
-    flex_lines: &mut [FlexLine],
-    node: Node,
+fn align_flex_lines_per_align_content<Tree: LayoutTree>(
+    tree: &Tree,
+    flex_lines: &mut [FlexLine<Tree::ChildId>],
     constants: &AlgoConstants,
     total_cross_size: f32,
 ) {
     let num_lines = flex_lines.len();
     let gap = constants.gap.cross(constants.dir);
-    let align_content_mode = tree.style(node).align_content.unwrap_or(AlignContent::Stretch);
+    let align_content_mode = tree.style().align_content.unwrap_or(AlignContent::Stretch);
     let total_cross_axis_gap = sum_axis_gaps(gap, num_lines);
     let free_space = constants.inner_container_size.cross(constants.dir) - total_cross_size - total_cross_axis_gap;
 
-    let align_line = |(i, line): (usize, &mut FlexLine)| {
+    let align_line = |(i, line): (usize, &mut FlexLine<Tree::ChildId>)| {
         line.offset_cross =
             compute_alignment_offset(free_space, num_lines, gap, align_content_mode, constants.is_wrap_reverse, i == 0);
     };
@@ -1666,10 +1666,9 @@ fn align_flex_lines_per_align_content(
 
 /// Calculates the layout for a flex-item
 #[allow(clippy::too_many_arguments)]
-fn calculate_flex_item(
-    tree: &mut impl LayoutTree,
-    node: Node,
-    item: &mut FlexItem,
+fn calculate_flex_item<Tree: LayoutTree>(
+    tree: &mut Tree,
+    item: &mut FlexItem<Tree::ChildId>,
     total_offset_main: &mut f32,
     total_offset_cross: f32,
     line_offset_cross: f32,
@@ -1677,8 +1676,7 @@ fn calculate_flex_item(
     node_inner_size: Size<Option<f32>>,
     direction: FlexDirection,
 ) {
-    let preliminary_size_and_baselines = GenericAlgorithm::perform_layout(
-        tree,
+    let preliminary_size_and_baselines = tree.perform_child_layout(
         item.node,
         item.target_size.map(|s| s.into()),
         node_inner_size,
@@ -1708,9 +1706,9 @@ fn calculate_flex_item(
         item.baseline = baseline_offset_main + inner_baseline;
     }
 
-    let order = tree.children(node).position(|n| *n == item.node).unwrap() as u32;
+    let order = tree.children().position(|n| n == item.node).unwrap() as u32;
 
-    *tree.layout_mut(item.node) = Layout {
+    *tree.child_layout_mut(item.node) = Layout {
         order,
         size: preliminary_size_and_baselines.size,
         location: Point {
@@ -1724,10 +1722,9 @@ fn calculate_flex_item(
 
 /// Calculates the layout line
 #[allow(clippy::too_many_arguments)]
-fn calculate_layout_line(
-    tree: &mut impl LayoutTree,
-    node: Node,
-    line: &mut FlexLine,
+fn calculate_layout_line<Tree: LayoutTree>(
+    tree: &mut Tree,
+    line: &mut FlexLine<Tree::ChildId>,
     total_offset_cross: &mut f32,
     container_size: Size<f32>,
     node_inner_size: Size<Option<f32>>,
@@ -1741,7 +1738,6 @@ fn calculate_layout_line(
         for item in line.items.iter_mut().rev() {
             calculate_flex_item(
                 tree,
-                node,
                 item,
                 &mut total_offset_main,
                 *total_offset_cross,
@@ -1755,7 +1751,6 @@ fn calculate_layout_line(
         for item in line.items.iter_mut() {
             calculate_flex_item(
                 tree,
-                node,
                 item,
                 &mut total_offset_main,
                 *total_offset_cross,
@@ -1772,14 +1767,17 @@ fn calculate_layout_line(
 
 /// Do a final layout pass and collect the resulting layouts.
 #[inline]
-fn final_layout_pass(tree: &mut impl LayoutTree, node: Node, flex_lines: &mut [FlexLine], constants: &AlgoConstants) {
+fn final_layout_pass<Tree: LayoutTree>(
+    tree: &mut Tree,
+    flex_lines: &mut [FlexLine<Tree::ChildId>],
+    constants: &AlgoConstants,
+) {
     let mut total_offset_cross = constants.padding_border.cross_start(constants.dir);
 
     if constants.is_wrap_reverse {
         for line in flex_lines.iter_mut().rev() {
             calculate_layout_line(
                 tree,
-                node,
                 line,
                 &mut total_offset_cross,
                 constants.container_size,
@@ -1792,7 +1790,6 @@ fn final_layout_pass(tree: &mut impl LayoutTree, node: Node, flex_lines: &mut [F
         for line in flex_lines.iter_mut() {
             calculate_layout_line(
                 tree,
-                node,
                 line,
                 &mut total_offset_cross,
                 constants.container_size,
@@ -1806,13 +1803,13 @@ fn final_layout_pass(tree: &mut impl LayoutTree, node: Node, flex_lines: &mut [F
 
 /// Perform absolute layout on all absolutely positioned children.
 #[inline]
-fn perform_absolute_layout_on_absolute_children(tree: &mut impl LayoutTree, node: Node, constants: &AlgoConstants) {
+fn perform_absolute_layout_on_absolute_children(tree: &mut impl LayoutTree, constants: &AlgoConstants) {
     let container_width = constants.container_size.width;
     let container_height = constants.container_size.height;
 
-    for order in 0..tree.child_count(node) {
-        let child = tree.child(node, order);
-        let child_style = tree.style(child);
+    for order in 0..tree.child_count() {
+        let child = tree.child(order);
+        let child_style = tree.child_style(child);
 
         // Skip items that are display:none or are not position:absolute
         if child_style.display == Display::None || child_style.position != Position::Absolute {
@@ -1856,8 +1853,7 @@ fn perform_absolute_layout_on_absolute_children(tree: &mut impl LayoutTree, node
             known_dimensions = known_dimensions.maybe_apply_aspect_ratio(aspect_ratio).maybe_clamp(min_size, max_size);
         }
 
-        let measured_size_and_baselines = GenericAlgorithm::perform_layout(
-            tree,
+        let measured_size_and_baselines = tree.perform_child_layout(
             child,
             known_dimensions,
             constants.node_inner_size,
@@ -1924,7 +1920,7 @@ fn perform_absolute_layout_on_absolute_children(tree: &mut impl LayoutTree, node
         } else {
             // Stretch is an invalid value for justify_content in the flexbox algorithm, so we
             // treat it as if it wasn't set (and thus we default to FlexStart behaviour)
-            match (tree.style(node).justify_content.unwrap_or(JustifyContent::Start), constants.is_wrap_reverse) {
+            match (tree.style().justify_content.unwrap_or(JustifyContent::Start), constants.is_wrap_reverse) {
                 (JustifyContent::SpaceBetween, _)
                 | (JustifyContent::Start, _)
                 | (JustifyContent::Stretch, false)
@@ -1992,7 +1988,7 @@ fn perform_absolute_layout_on_absolute_children(tree: &mut impl LayoutTree, node
             }
         };
 
-        *tree.layout_mut(child) = Layout {
+        *tree.child_layout_mut(child) = Layout {
             order: order as u32,
             size: final_size,
             location: Point {
diff --git a/src/compute/grid/alignment.rs b/src/compute/grid/alignment.rs
index 0c0ed9f81..e7137e669 100644
--- a/src/compute/grid/alignment.rs
+++ b/src/compute/grid/alignment.rs
@@ -2,11 +2,9 @@
 use super::types::GridTrack;
 use crate::axis::InBothAbsAxis;
 use crate::compute::common::alignment::compute_alignment_offset;
-use crate::compute::{GenericAlgorithm, LayoutAlgorithm};
 use crate::geometry::{Line, Point, Rect, Size};
 use crate::layout::{Layout, SizingMode};
 use crate::math::MaybeMath;
-use crate::node::Node;
 use crate::resolve::MaybeResolve;
 use crate::style::{AlignContent, AlignItems, AlignSelf, AvailableSpace, Position};
 use crate::sys::{f32_max, f32_min};
@@ -72,9 +70,9 @@ pub(super) fn align_tracks(
 }
 
 /// Align and size a grid item into it's final position
-pub(super) fn align_and_position_item(
-    tree: &mut impl LayoutTree,
-    node: Node,
+pub(super) fn align_and_position_item<Tree: LayoutTree>(
+    tree: &mut Tree,
+    node: Tree::ChildId,
     order: u32,
     grid_area: Rect<f32>,
     container_alignment_styles: InBothAbsAxis<Option<AlignItems>>,
@@ -82,7 +80,7 @@ pub(super) fn align_and_position_item(
 ) {
     let grid_area_size = Size { width: grid_area.right - grid_area.left, height: grid_area.bottom - grid_area.top };
 
-    let style = tree.style(node);
+    let style = tree.child_style(node);
     let aspect_ratio = style.aspect_ratio;
     let justify_self = style.justify_self;
     let align_self = style.align_self;
@@ -180,8 +178,7 @@ pub(super) fn align_and_position_item(
     let Size { width, height } = Size { width, height }.maybe_clamp(min_size, max_size);
 
     // Layout node
-    let measured_size_and_baselines = GenericAlgorithm::perform_layout(
-        tree,
+    let measured_size_and_baselines = tree.perform_child_layout(
         node,
         Size { width, height },
         grid_area_size.map(Option::Some),
@@ -212,7 +209,7 @@ pub(super) fn align_and_position_item(
         baseline_shim,
     );
 
-    *tree.layout_mut(node) = Layout { order, size: Size { width, height }, location: Point { x, y } };
+    *tree.child_layout_mut(node) = Layout { order, size: Size { width, height }, location: Point { x, y } };
 }
 
 /// Align and size a grid item along a single axis
diff --git a/src/compute/grid/mod.rs b/src/compute/grid/mod.rs
index 4e691eae5..c2dedaffa 100644
--- a/src/compute/grid/mod.rs
+++ b/src/compute/grid/mod.rs
@@ -4,7 +4,6 @@ use crate::axis::{AbsoluteAxis, AbstractAxis, InBothAbsAxis};
 use crate::geometry::{Line, Point, Rect, Size};
 use crate::layout::{Layout, RunMode, SizeAndBaselines, SizingMode};
 use crate::math::MaybeMath;
-use crate::node::Node;
 use crate::resolve::{MaybeResolve, ResolveOrZero};
 use crate::style::{AlignContent, AlignItems, AlignSelf, AvailableSpace, Display, Position};
 use crate::style_helpers::*;
@@ -17,14 +16,14 @@ use placement::place_grid_items;
 use track_sizing::{
     determine_if_item_crosses_flexible_or_intrinsic_tracks, resolve_item_track_indexes, track_sizing_algorithm,
 };
-use types::{CellOccupancyMatrix, GridTrack};
+use types::{CellOccupancyMatrix, GridItem, GridTrack};
 
 pub(crate) use types::{GridCoordinate, GridLine, OriginZeroLine};
 
 #[cfg(feature = "debug")]
 use crate::debug::NODE_LOGGER;
 
-use super::{GenericAlgorithm, LayoutAlgorithm};
+use super::LayoutAlgorithm;
 
 mod alignment;
 mod explicit_grid;
@@ -35,30 +34,30 @@ mod types;
 mod util;
 
 /// The public interface to Taffy's CSS Grid algorithm implementation
-pub(crate) struct CssGridAlgorithm;
+pub struct CssGridAlgorithm;
 impl LayoutAlgorithm for CssGridAlgorithm {
     const NAME: &'static str = "CSS GRID";
 
+    #[inline(always)]
     fn perform_layout(
         tree: &mut impl LayoutTree,
-        node: Node,
         known_dimensions: Size<Option<f32>>,
         parent_size: Size<Option<f32>>,
         available_space: Size<AvailableSpace>,
         _sizing_mode: SizingMode,
     ) -> SizeAndBaselines {
-        compute(tree, node, known_dimensions, parent_size, available_space, RunMode::PeformLayout)
+        compute(tree, known_dimensions, parent_size, available_space, RunMode::PeformLayout)
     }
 
+    #[inline(always)]
     fn measure_size(
         tree: &mut impl LayoutTree,
-        node: Node,
         known_dimensions: Size<Option<f32>>,
         parent_size: Size<Option<f32>>,
         available_space: Size<AvailableSpace>,
         _sizing_mode: SizingMode,
     ) -> Size<f32> {
-        compute(tree, node, known_dimensions, parent_size, available_space, RunMode::ComputeSize).size
+        compute(tree, known_dimensions, parent_size, available_space, RunMode::ComputeSize).size
     }
 }
 
@@ -68,17 +67,16 @@ impl LayoutAlgorithm for CssGridAlgorithm {
 ///   - Placing items (which also resolves the implicit grid)
 ///   - Track (row/column) sizing
 ///   - Alignment & Final item placement
-pub fn compute(
-    tree: &mut impl LayoutTree,
-    node: Node,
+pub fn compute<Tree: LayoutTree>(
+    tree: &mut Tree,
     known_dimensions: Size<Option<f32>>,
     parent_size: Size<Option<f32>>,
     available_space: Size<AvailableSpace>,
     run_mode: RunMode,
 ) -> SizeAndBaselines {
-    let get_child_styles_iter = |node| tree.children(node).map(|child_node: &Node| tree.style(*child_node));
-    let style = tree.style(node).clone();
-    let child_styles_iter = get_child_styles_iter(node);
+    let get_child_styles_iter = || tree.children().map(|child_node: Tree::ChildId| tree.child_style(child_node));
+    let style = tree.style().clone();
+    let child_styles_iter = get_child_styles_iter();
 
     // 1. Resolve the explicit grid
     // Exactly compute the number of rows and columns in the explicit grid.
@@ -93,13 +91,12 @@ pub fn compute(
 
     // 2. Grid Item Placement
     // Match items (children) to a definite grid position (row start/end and column start/end position)
-    let mut items = Vec::with_capacity(tree.child_count(node));
+    let mut items: Vec<GridItem<Tree>> = Vec::with_capacity(tree.child_count());
     let mut cell_occupancy_matrix = CellOccupancyMatrix::with_track_counts(est_col_counts, est_row_counts);
     let in_flow_children_iter = || {
-        tree.children(node)
-            .copied()
+        tree.children()
             .enumerate()
-            .map(|(index, child_node)| (index, child_node, tree.style(child_node)))
+            .map(|(index, child_node)| (index, child_node, tree.child_style(child_node)))
             .filter(|(_, _, style)| style.display != Display::None && style.position != Position::Absolute)
     };
     place_grid_items(
@@ -443,21 +440,14 @@ pub fn compute(
 
     // Position hidden and absolutely positioned children
     let mut order = items.len() as u32;
-    (0..tree.child_count(node)).for_each(|index| {
-        let child = tree.child(node, index);
-        let child_style = tree.style(child);
+    (0..tree.child_count()).for_each(|index| {
+        let child = tree.child(index);
+        let child_style = tree.child_style(child);
 
         // Position hidden child
         if child_style.display == Display::None {
-            *tree.layout_mut(node) = Layout::with_order(order);
-            GenericAlgorithm::perform_layout(
-                tree,
-                child,
-                Size::NONE,
-                Size::NONE,
-                Size::MAX_CONTENT,
-                SizingMode::InherentSize,
-            );
+            *tree.layout_mut() = Layout::with_order(order);
+            tree.perform_child_layout(child, Size::NONE, Size::NONE, Size::MAX_CONTENT, SizingMode::InherentSize);
             order += 1;
             return;
         }
@@ -526,7 +516,7 @@ pub fn compute(
             &first_row_items[0]
         };
 
-        let layout = tree.layout_mut(item.node);
+        let layout = tree.child_layout_mut(item.node);
         layout.location.y + item.baseline.unwrap_or(layout.size.height)
     };
 
diff --git a/src/compute/grid/placement.rs b/src/compute/grid/placement.rs
index d02e7af8e..bdee01cc8 100644
--- a/src/compute/grid/placement.rs
+++ b/src/compute/grid/placement.rs
@@ -4,23 +4,23 @@ use super::types::{CellOccupancyMatrix, CellOccupancyState, GridItem};
 use super::OriginZeroLine;
 use crate::axis::{AbsoluteAxis, InBothAbsAxis};
 use crate::geometry::Line;
-use crate::node::Node;
 use crate::style::{AlignItems, GridAutoFlow, OriginZeroGridPlacement, Style};
 use crate::sys::Vec;
+use crate::tree::LayoutTree;
 
 /// 8.5. Grid Item Placement Algorithm
 /// Place items into the grid, generating new rows/column into the implicit grid as required
 ///
 /// [Specification](https://www.w3.org/TR/css-grid-2/#auto-placement-algo)
-pub(super) fn place_grid_items<'a, ChildIter>(
+pub(super) fn place_grid_items<'a, ChildIter, Tree: LayoutTree>(
     cell_occupancy_matrix: &mut CellOccupancyMatrix,
-    items: &mut Vec<GridItem>,
+    items: &mut Vec<GridItem<Tree>>,
     children_iter: impl Fn() -> ChildIter,
     grid_auto_flow: GridAutoFlow,
     align_items: AlignItems,
     justify_items: AlignItems,
 ) where
-    ChildIter: Iterator<Item = (usize, Node, &'a Style)>,
+    ChildIter: Iterator<Item = (usize, Tree::ChildId, &'a Style)>,
 {
     let primary_axis = grid_auto_flow.primary_axis();
     let secondary_axis = primary_axis.other_axis();
@@ -28,7 +28,7 @@ pub(super) fn place_grid_items<'a, ChildIter>(
     let map_child_style_to_origin_zero_placement = {
         let explicit_col_count = cell_occupancy_matrix.track_counts(AbsoluteAxis::Horizontal).explicit;
         let explicit_row_count = cell_occupancy_matrix.track_counts(AbsoluteAxis::Vertical).explicit;
-        move |(index, node, style): (usize, Node, &'a Style)| -> (_, _, _, &'a Style) {
+        move |(index, node, style): (usize, Tree::ChildId, &'a Style)| -> (_, _, _, &'a Style) {
             let origin_zero_placement = InBothAbsAxis {
                 horizontal: style.grid_column.map(|placement| placement.into_origin_zero_placement(explicit_col_count)),
                 vertical: style.grid_row.map(|placement| placement.into_origin_zero_placement(explicit_row_count)),
@@ -294,10 +294,10 @@ fn place_indefinitely_positioned_item(
 /// Record the grid item in both CellOccupancyMatric and the GridItems list
 /// once a definite placement has been determined
 #[allow(clippy::too_many_arguments)]
-fn record_grid_placement(
+fn record_grid_placement<Tree: LayoutTree>(
     cell_occupancy_matrix: &mut CellOccupancyMatrix,
-    items: &mut Vec<GridItem>,
-    node: Node,
+    items: &mut Vec<GridItem<Tree>>,
+    node: Tree::ChildId,
     index: usize,
     style: &Style,
     parent_align_items: AlignItems,
@@ -346,9 +346,10 @@ mod tests {
 
     mod test_placement_algorithm {
         use crate::compute::grid::implicit_grid::compute_grid_size_estimate;
-        use crate::compute::grid::types::TrackCounts;
+        use crate::compute::grid::types::{GridItem, TrackCounts};
         use crate::compute::grid::util::*;
         use crate::compute::grid::CellOccupancyMatrix;
+        use crate::node::TaffyNodeRef;
         use crate::prelude::*;
         use crate::style::GridAutoFlow;
         use slotmap::SlotMap;
@@ -369,7 +370,7 @@ mod tests {
             let children_iter = || children.iter().map(|(index, node, style, _)| (*index, *node, style));
             let child_styles_iter = children.iter().map(|(_, _, style, _)| style);
             let estimated_sizes = compute_grid_size_estimate(explicit_col_count, explicit_row_count, child_styles_iter);
-            let mut items = Vec::new();
+            let mut items: Vec<GridItem<TaffyNodeRef>> = Vec::new();
             let mut cell_occupancy_matrix =
                 CellOccupancyMatrix::with_track_counts(estimated_sizes.0, estimated_sizes.1);
 
diff --git a/src/compute/grid/track_sizing.rs b/src/compute/grid/track_sizing.rs
index 7d1994dd7..4852f8a65 100644
--- a/src/compute/grid/track_sizing.rs
+++ b/src/compute/grid/track_sizing.rs
@@ -2,16 +2,16 @@
 //! <https://www.w3.org/TR/css-grid-1/#layout-algorithm>
 use super::types::{GridItem, GridTrack, TrackCounts};
 use crate::axis::AbstractAxis;
-use crate::compute::{GenericAlgorithm, LayoutAlgorithm};
 use crate::geometry::Size;
 use crate::layout::SizingMode;
 use crate::math::MaybeMath;
-use crate::prelude::{LayoutTree, TaffyMinContent};
 use crate::resolve::ResolveOrZero;
 use crate::style::{
     AlignContent, AlignSelf, AvailableSpace, LengthPercentage, MaxTrackSizingFunction, MinTrackSizingFunction,
 };
+use crate::style_helpers::TaffyMinContent;
 use crate::sys::{f32_max, f32_min};
+use crate::tree::LayoutTree;
 use core::cmp::Ordering;
 
 /// Takes an axis, and a list of grid items sorted firstly by whether they cross a flex track
@@ -37,8 +37,10 @@ impl ItemBatcher {
 
     /// This is basically a manual version of Iterator::next which passes `items`
     /// in as a parameter on each iteration to work around borrow checker rules
-    #[inline]
-    fn next<'items>(&mut self, items: &'items mut [GridItem]) -> Option<(&'items mut [GridItem], bool)> {
+    fn next<'items, Tree: LayoutTree>(
+        &mut self,
+        items: &'items mut [GridItem<Tree>],
+    ) -> Option<(&'items mut [GridItem<Tree>], bool)> {
         if self.current_is_flex || self.index_offset >= items.len() {
             return None;
         }
@@ -52,7 +54,7 @@ impl ItemBatcher {
         } else {
             items
                 .iter()
-                .position(|item: &GridItem| {
+                .position(|item: &GridItem<Tree>| {
                     item.crosses_flexible_track(self.axis) || item.span(self.axis) > self.current_span
                 })
                 .unwrap_or(items.len())
@@ -96,7 +98,7 @@ where
     /// axis to the one currently being sized.
     /// https://www.w3.org/TR/css-grid-1/#algo-overview
     #[inline(always)]
-    fn available_space(&self, item: &mut GridItem) -> Size<Option<f32>> {
+    fn available_space(&self, item: &mut GridItem<Tree>) -> Size<Option<f32>> {
         item.available_space_cached(
             self.axis,
             self.other_axis_tracks,
@@ -108,13 +110,13 @@ where
     /// Compute the item's resolved margins for size contributions. Horizontal percentage margins always resolve
     /// to zero if the container size is indefinite as otherwise this would introduce a cyclic dependency.
     #[inline(always)]
-    fn margins_axis_sums_with_baseline_shims(&self, item: &mut GridItem) -> Size<f32> {
+    fn margins_axis_sums_with_baseline_shims(&self, item: &mut GridItem<Tree>) -> Size<f32> {
         item.margins_axis_sums_with_baseline_shims(self.inner_node_size.width)
     }
 
     /// Retrieve the item's min content contribution from the cache or compute it using the provided parameters
     #[inline(always)]
-    fn min_content_contribution(&mut self, item: &mut GridItem) -> f32 {
+    fn min_content_contribution(&mut self, item: &mut GridItem<Tree>) -> f32 {
         let available_space = self.available_space(item);
         let margin_axis_sums = self.margins_axis_sums_with_baseline_shims(item);
         let contribution =
@@ -124,7 +126,7 @@ where
 
     /// Retrieve the item's max content contribution from the cache or compute it using the provided parameters
     #[inline(always)]
-    fn max_content_contribution(&mut self, item: &mut GridItem) -> f32 {
+    fn max_content_contribution(&mut self, item: &mut GridItem<Tree>) -> f32 {
         let available_space = self.available_space(item);
         let margin_axis_sums = self.margins_axis_sums_with_baseline_shims(item);
         let contribution =
@@ -139,7 +141,7 @@ where
     ///   - Else the item’s minimum contribution is its min-content contribution.
     /// Because the minimum contribution often depends on the size of the item’s content, it is considered a type of intrinsic size contribution.
     #[inline(always)]
-    fn minimum_contribution(&mut self, item: &mut GridItem, axis_tracks: &[GridTrack]) -> f32 {
+    fn minimum_contribution(&mut self, item: &mut GridItem<Tree>, axis_tracks: &[GridTrack]) -> f32 {
         let available_space = self.available_space(item);
         let margin_axis_sums = self.margins_axis_sums_with_baseline_shims(item);
         let contribution =
@@ -151,10 +153,10 @@ where
 /// To make track sizing efficient we want to order tracks
 /// Here a placement is either a Line<i16> representing a row-start/row-end or a column-start/column-end
 #[inline(always)]
-pub(super) fn cmp_by_cross_flex_then_span_then_start(
+pub(super) fn cmp_by_cross_flex_then_span_then_start<Tree: LayoutTree>(
     axis: AbstractAxis,
-) -> impl FnMut(&GridItem, &GridItem) -> Ordering {
-    move |item_a: &GridItem, item_b: &GridItem| -> Ordering {
+) -> impl FnMut(&GridItem<Tree>, &GridItem<Tree>) -> Ordering {
+    move |item_a: &GridItem<Tree>, item_b: &GridItem<Tree>| -> Ordering {
         match (item_a.crosses_flexible_track(axis), item_b.crosses_flexible_track(axis)) {
             (false, true) => Ordering::Less,
             (true, false) => Ordering::Greater,
@@ -233,8 +235,11 @@ pub(super) fn compute_alignment_gutter_adjustment(
 }
 
 /// Convert origin-zero coordinates track placement in grid track vector indexes
-#[inline(always)]
-pub(super) fn resolve_item_track_indexes(items: &mut [GridItem], column_counts: TrackCounts, row_counts: TrackCounts) {
+pub(super) fn resolve_item_track_indexes<Tree: LayoutTree>(
+    items: &mut [GridItem<Tree>],
+    column_counts: TrackCounts,
+    row_counts: TrackCounts,
+) {
     for item in items {
         item.column_indexes = item.column.map(|line| line.into_track_vec_index(column_counts) as u16);
         item.row_indexes = item.row.map(|line| line.into_track_vec_index(row_counts) as u16);
@@ -242,9 +247,8 @@ pub(super) fn resolve_item_track_indexes(items: &mut [GridItem], column_counts:
 }
 
 /// Determine (in each axis) whether the item crosses any flexible tracks
-#[inline(always)]
-pub(super) fn determine_if_item_crosses_flexible_or_intrinsic_tracks(
-    items: &mut Vec<GridItem>,
+pub(super) fn determine_if_item_crosses_flexible_or_intrinsic_tracks<Tree: LayoutTree>(
+    items: &mut Vec<GridItem<Tree>>,
     columns: &[GridTrack],
     rows: &[GridTrack],
 ) {
@@ -274,7 +278,7 @@ pub(super) fn track_sizing_algorithm<Tree: LayoutTree>(
     inner_node_size: Size<Option<f32>>,
     axis_tracks: &mut [GridTrack],
     other_axis_tracks: &mut [GridTrack],
-    items: &mut [GridItem],
+    items: &mut [GridItem<Tree>],
     get_track_size_estimate: impl Fn(&GridTrack, Option<f32>) -> Option<f32>,
     has_baseline_aligned_item: bool,
 ) {
@@ -425,10 +429,10 @@ fn initialize_track_sizes(axis_tracks: &mut [GridTrack], axis_inner_node_size: O
 }
 
 /// 11.5.1 Shim baseline-aligned items so their intrinsic size contributions reflect their baseline alignment.
-fn resolve_item_baselines(
-    tree: &mut impl LayoutTree,
+fn resolve_item_baselines<Tree: LayoutTree>(
+    tree: &mut Tree,
     axis: AbstractAxis,
-    items: &mut [GridItem],
+    items: &mut [GridItem<Tree>],
     inner_node_size: Size<Option<f32>>,
 ) {
     // Sort items by track in the other axis (row) start position so that we can iterate items in groups which
@@ -470,8 +474,7 @@ fn resolve_item_baselines(
 
         // Compute the baselines of all items in the row
         for item in row_items.iter_mut() {
-            let measured_size_and_baselines = GenericAlgorithm::perform_layout(
-                tree,
+            let measured_size_and_baselines = tree.perform_child_layout(
                 item.node,
                 Size::NONE,
                 inner_node_size,
@@ -498,12 +501,12 @@ fn resolve_item_baselines(
 
 /// 11.5 Resolve Intrinsic Track Sizes
 #[allow(clippy::too_many_arguments)]
-fn resolve_intrinsic_track_sizes(
-    tree: &mut impl LayoutTree,
+fn resolve_intrinsic_track_sizes<Tree: LayoutTree>(
+    tree: &mut Tree,
     axis: AbstractAxis,
     axis_tracks: &mut [GridTrack],
     other_axis_tracks: &mut [GridTrack],
-    items: &mut [GridItem],
+    items: &mut [GridItem<Tree>],
     axis_available_grid_space: AvailableSpace,
     inner_node_size: Size<Option<f32>>,
     get_track_size_estimate: impl Fn(&GridTrack, Option<f32>) -> Option<f32>,
@@ -1076,11 +1079,11 @@ fn maximise_tracks(
 /// This step sizes flexible tracks using the largest value it can assign to an fr without exceeding the available space.
 #[allow(clippy::too_many_arguments)]
 #[inline(always)]
-fn expand_flexible_tracks(
-    tree: &mut impl LayoutTree,
+fn expand_flexible_tracks<Tree: LayoutTree>(
+    tree: &mut Tree,
     axis: AbstractAxis,
     axis_tracks: &mut [GridTrack],
-    items: &mut [GridItem],
+    items: &mut [GridItem<Tree>],
     axis_min_size: Option<f32>,
     axis_max_size: Option<f32>,
     available_grid_space: Size<AvailableSpace>,
diff --git a/src/compute/grid/types/grid_item.rs b/src/compute/grid/types/grid_item.rs
index 513038d2f..d868a72ca 100644
--- a/src/compute/grid/types/grid_item.rs
+++ b/src/compute/grid/types/grid_item.rs
@@ -2,11 +2,9 @@
 use super::GridTrack;
 use crate::axis::AbstractAxis;
 use crate::compute::grid::OriginZeroLine;
-use crate::compute::{GenericAlgorithm, LayoutAlgorithm};
 use crate::geometry::{Line, Rect, Size};
 use crate::layout::SizingMode;
 use crate::math::MaybeMath;
-use crate::node::Node;
 use crate::prelude::LayoutTree;
 use crate::resolve::{MaybeResolve, ResolveOrZero};
 use crate::style::{
@@ -16,9 +14,9 @@ use core::ops::Range;
 
 /// Represents a single grid item
 #[derive(Debug)]
-pub(in super::super) struct GridItem {
+pub(in super::super) struct GridItem<Tree: LayoutTree> {
     /// The id of the Node that this item represents
-    pub node: Node,
+    pub node: Tree::ChildId,
 
     /// The order of the item in the children array
     ///
@@ -72,10 +70,10 @@ pub(in super::super) struct GridItem {
     pub max_content_contribution_cache: Size<Option<f32>>,
 }
 
-impl GridItem {
+impl<Tree: LayoutTree> GridItem<Tree> {
     /// Create a new item given a concrete placement in both axes
     pub fn new_with_placement_style_and_order(
-        node: Node,
+        node: Tree::ChildId,
         col_span: Line<OriginZeroLine>,
         row_span: Line<OriginZeroLine>,
         style: &Style,
@@ -207,13 +205,13 @@ impl GridItem {
     /// allow percentage sizes further down the tree to resolve properly in some cases
     fn known_dimensions(
         &self,
-        tree: &mut impl LayoutTree,
+        tree: &mut Tree,
         inner_node_size: Size<Option<f32>>,
         grid_area_size: Size<Option<f32>>,
     ) -> Size<Option<f32>> {
         let margins = self.margins_axis_sums_with_baseline_shims(inner_node_size.width);
 
-        let style = tree.style(self.node);
+        let style = tree.child_style(self.node);
         let aspect_ratio = style.aspect_ratio;
         let inherent_size = style.size.maybe_resolve(grid_area_size).maybe_apply_aspect_ratio(aspect_ratio);
         let min_size = style.min_size.maybe_resolve(grid_area_size).maybe_apply_aspect_ratio(aspect_ratio);
@@ -323,13 +321,12 @@ impl GridItem {
     pub fn min_content_contribution(
         &self,
         axis: AbstractAxis,
-        tree: &mut impl LayoutTree,
+        tree: &mut Tree,
         available_space: Size<Option<f32>>,
         inner_node_size: Size<Option<f32>>,
     ) -> f32 {
         let known_dimensions = self.known_dimensions(tree, inner_node_size, available_space);
-        GenericAlgorithm::measure_size(
-            tree,
+        tree.measure_child_size(
             self.node,
             known_dimensions,
             available_space,
@@ -347,7 +344,7 @@ impl GridItem {
     pub fn min_content_contribution_cached(
         &mut self,
         axis: AbstractAxis,
-        tree: &mut impl LayoutTree,
+        tree: &mut Tree,
         available_space: Size<Option<f32>>,
         inner_node_size: Size<Option<f32>>,
     ) -> f32 {
@@ -362,13 +359,12 @@ impl GridItem {
     pub fn max_content_contribution(
         &self,
         axis: AbstractAxis,
-        tree: &mut impl LayoutTree,
+        tree: &mut Tree,
         available_space: Size<Option<f32>>,
         inner_node_size: Size<Option<f32>>,
     ) -> f32 {
         let known_dimensions = self.known_dimensions(tree, inner_node_size, available_space);
-        GenericAlgorithm::measure_size(
-            tree,
+        tree.measure_child_size(
             self.node,
             known_dimensions,
             available_space,
@@ -386,7 +382,7 @@ impl GridItem {
     pub fn max_content_contribution_cached(
         &mut self,
         axis: AbstractAxis,
-        tree: &mut impl LayoutTree,
+        tree: &mut Tree,
         available_space: Size<Option<f32>>,
         inner_node_size: Size<Option<f32>>,
     ) -> f32 {
@@ -406,13 +402,13 @@ impl GridItem {
     /// See: https://www.w3.org/TR/css-grid-1/#min-size-auto
     pub fn minimum_contribution(
         &mut self,
-        tree: &mut impl LayoutTree,
+        tree: &mut Tree,
         axis: AbstractAxis,
         axis_tracks: &[GridTrack],
         known_dimensions: Size<Option<f32>>,
         inner_node_size: Size<Option<f32>>,
     ) -> f32 {
-        let style = tree.style(self.node);
+        let style = tree.child_style(self.node);
         let size = style
             .size
             .maybe_resolve(inner_node_size)
@@ -465,7 +461,7 @@ impl GridItem {
     #[inline(always)]
     pub fn minimum_contribution_cached(
         &mut self,
-        tree: &mut impl LayoutTree,
+        tree: &mut Tree,
         axis: AbstractAxis,
         axis_tracks: &[GridTrack],
         known_dimensions: Size<Option<f32>>,
diff --git a/src/compute/leaf.rs b/src/compute/leaf.rs
index 2c347a64d..38be24e3a 100644
--- a/src/compute/leaf.rs
+++ b/src/compute/leaf.rs
@@ -1,56 +1,52 @@
 //! Computes size using styles and measure functions
 
-use crate::compute::LayoutAlgorithm;
 use crate::geometry::{Point, Size};
 use crate::layout::{SizeAndBaselines, SizingMode};
 use crate::math::MaybeMath;
-use crate::node::Node;
+use crate::node::{Node, Taffy};
 use crate::resolve::{MaybeResolve, ResolveOrZero};
 use crate::style::AvailableSpace;
 use crate::sys::f32_max;
-use crate::tree::LayoutTree;
 
 #[cfg(feature = "debug")]
 use crate::debug::NODE_LOGGER;
 
-/// The public interface to Taffy's leaf node algorithm implementation
-pub(crate) struct LeafAlgorithm;
-impl LayoutAlgorithm for LeafAlgorithm {
-    const NAME: &'static str = "LEAF";
-
-    fn perform_layout(
-        tree: &mut impl LayoutTree,
-        node: Node,
-        known_dimensions: Size<Option<f32>>,
-        parent_size: Size<Option<f32>>,
-        available_space: Size<AvailableSpace>,
-        sizing_mode: SizingMode,
-    ) -> SizeAndBaselines {
-        compute(tree, node, known_dimensions, parent_size, available_space, sizing_mode)
-    }
+/// Compute the size of the node given the specified constraints
+#[inline(always)]
+pub(crate) fn perform_layout(
+    tree: &mut Taffy,
+    node: Node,
+    known_dimensions: Size<Option<f32>>,
+    parent_size: Size<Option<f32>>,
+    available_space: Size<AvailableSpace>,
+    sizing_mode: SizingMode,
+) -> SizeAndBaselines {
+    compute(tree, node, known_dimensions, parent_size, available_space, sizing_mode)
+}
 
-    fn measure_size(
-        tree: &mut impl LayoutTree,
-        node: Node,
-        known_dimensions: Size<Option<f32>>,
-        parent_size: Size<Option<f32>>,
-        available_space: Size<AvailableSpace>,
-        sizing_mode: SizingMode,
-    ) -> Size<f32> {
-        compute(tree, node, known_dimensions, parent_size, available_space, sizing_mode).size
-    }
+/// Perform a full layout on the node given the specified constraints
+#[inline(always)]
+pub(crate) fn measure_size(
+    tree: &mut Taffy,
+    node: Node,
+    known_dimensions: Size<Option<f32>>,
+    parent_size: Size<Option<f32>>,
+    available_space: Size<AvailableSpace>,
+    sizing_mode: SizingMode,
+) -> Size<f32> {
+    compute(tree, node, known_dimensions, parent_size, available_space, sizing_mode).size
 }
 
 /// Compute the size of a leaf node (node with no children)
 pub(crate) fn compute(
-    tree: &mut impl LayoutTree,
+    tree: &mut Taffy,
     node: Node,
     known_dimensions: Size<Option<f32>>,
     parent_size: Size<Option<f32>>,
     available_space: Size<AvailableSpace>,
     sizing_mode: SizingMode,
 ) -> SizeAndBaselines {
-    let style = tree.style(node);
+    let style = &tree.nodes[node].style;
 
     // Resolve node's preferred/min/max sizes (width/heights) against the available space (percentages resolve to pixel values)
     // For ContentSize mode, we pretend that the node has no size styles as these should be ignored.
@@ -87,7 +83,7 @@ pub(crate) fn compute(
         return SizeAndBaselines { size, first_baselines: Point::NONE };
     };
 
-    if tree.needs_measure(node) {
+    if let Some(measure_func) = tree.measure_funcs.get_mut(node) {
         // Compute available space
         let available_space = Size {
             width: available_space
@@ -103,7 +99,7 @@ pub(crate) fn compute(
         };
 
         // Measure node
-        let measured_size = tree.measure_node(node, known_dimensions, available_space);
+        let measured_size = measure_func.measure(known_dimensions, available_space);
 
         let measured_size = Size {
             width: measured_size.width,
diff --git a/src/compute/mod.rs b/src/compute/mod.rs
index 479644b91..e1d41bd39 100644
--- a/src/compute/mod.rs
+++ b/src/compute/mod.rs
@@ -7,30 +7,23 @@ pub(crate) mod leaf;
 #[cfg(feature = "grid")]
 pub(crate) mod grid;
 
-use crate::data::CACHE_SIZE;
 use crate::error::TaffyError;
 use crate::geometry::{Point, Size};
-use crate::layout::{Cache, Layout, RunMode, SizeAndBaselines, SizingMode};
-use crate::node::Node;
+use crate::layout::{Layout, RunMode, SizeAndBaselines, SizingMode};
+use crate::node::{Node, Taffy};
 use crate::style::{AvailableSpace, Display};
-use crate::sys::round;
 use crate::tree::LayoutTree;
 
 use self::flexbox::FlexboxAlgorithm;
 use self::grid::CssGridAlgorithm;
-use self::leaf::LeafAlgorithm;
 
 #[cfg(any(feature = "debug", feature = "profile"))]
 use crate::debug::NODE_LOGGER;
 
 /// Updates the stored layout of the provided `node` and its children
-pub fn compute_layout(
-    tree: &mut impl LayoutTree,
-    root: Node,
-    available_space: Size<AvailableSpace>,
-) -> Result<(), TaffyError> {
+pub fn compute_layout(tree: &mut Taffy, root: Node, available_space: Size<AvailableSpace>) -> Result<(), TaffyError> {
     // Recursively compute node layout
-    let size_and_baselines = GenericAlgorithm::perform_layout(
+    let size_and_baselines = perform_layout(
         tree,
         root,
         Size::NONE,
@@ -40,23 +33,22 @@ pub fn compute_layout(
     );
 
     let layout = Layout { order: 0, size: size_and_baselines.size, location: Point::ZERO };
-    *tree.layout_mut(root) = layout;
+    tree.nodes[root].layout = layout;
 
     // Recursively round the layout's of this node and all children
-    round_layout(tree, root);
+    recursively_round_layout(tree, root);
 
     Ok(())
 }
 
 /// A common interface that all Taffy layout algorithms conform to
-pub(crate) trait LayoutAlgorithm {
+pub trait LayoutAlgorithm {
     /// The name of the algorithm (mainly used for debug purposes)
     const NAME: &'static str;
 
     /// Compute the size of the node given the specified constraints
     fn measure_size(
         tree: &mut impl LayoutTree,
-        node: Node,
         known_dimensions: Size<Option<f32>>,
         parent_size: Size<Option<f32>>,
         available_space: Size<AvailableSpace>,
@@ -66,7 +58,6 @@ pub(crate) trait LayoutAlgorithm {
     /// Perform a full layout on the node given the specified constraints
     fn perform_layout(
         tree: &mut impl LayoutTree,
-        node: Node,
         known_dimensions: Size<Option<f32>>,
         parent_size: Size<Option<f32>>,
         available_space: Size<AvailableSpace>,
@@ -74,55 +65,36 @@ pub(crate) trait LayoutAlgorithm {
     ) -> SizeAndBaselines;
 }
 
-/// The public interface to a generic algorithm that abstracts over all of Taffy's algorithms
-/// and applies the correct one based on the `Display` style
-pub struct GenericAlgorithm;
-impl LayoutAlgorithm for GenericAlgorithm {
-    const NAME: &'static str = "GENERIC";
-
-    fn perform_layout(
-        tree: &mut impl LayoutTree,
-        node: Node,
-        known_dimensions: Size<Option<f32>>,
-        parent_size: Size<Option<f32>>,
-        available_space: Size<AvailableSpace>,
-        sizing_mode: SizingMode,
-    ) -> SizeAndBaselines {
-        compute_node_layout(
-            tree,
-            node,
-            known_dimensions,
-            parent_size,
-            available_space,
-            RunMode::PeformLayout,
-            sizing_mode,
-        )
-    }
+/// Compute the size of the node given the specified constraints
+#[inline(always)]
+pub(crate) fn perform_layout(
+    tree: &mut Taffy,
+    node: Node,
+    known_dimensions: Size<Option<f32>>,
+    parent_size: Size<Option<f32>>,
+    available_space: Size<AvailableSpace>,
+    sizing_mode: SizingMode,
+) -> SizeAndBaselines {
+    compute_node_layout(tree, node, known_dimensions, parent_size, available_space, RunMode::PeformLayout, sizing_mode)
+}
 
-    fn measure_size(
-        tree: &mut impl LayoutTree,
-        node: Node,
-        known_dimensions: Size<Option<f32>>,
-        parent_size: Size<Option<f32>>,
-        available_space: Size<AvailableSpace>,
-        sizing_mode: SizingMode,
-    ) -> Size<f32> {
-        compute_node_layout(
-            tree,
-            node,
-            known_dimensions,
-            parent_size,
-            available_space,
-            RunMode::ComputeSize,
-            sizing_mode,
-        )
+/// Perform a full layout on the node given the specified constraints
+#[inline(always)]
+pub(crate) fn measure_size(
+    tree: &mut Taffy,
+    node: Node,
+    known_dimensions: Size<Option<f32>>,
+    parent_size: Size<Option<f32>>,
+    available_space: Size<AvailableSpace>,
+    sizing_mode: SizingMode,
+) -> Size<f32> {
+    compute_node_layout(tree, node, known_dimensions, parent_size, available_space, RunMode::ComputeSize, sizing_mode)
         .size
-    }
 }
 
 /// Updates the stored layout of the provided `node` and its children
 fn compute_node_layout(
-    tree: &mut impl LayoutTree,
+    tree: &mut Taffy,
     node: Node,
     known_dimensions: Size<Option<f32>>,
     parent_size: Size<Option<f32>>,
@@ -135,11 +107,12 @@ fn compute_node_layout(
     #[cfg(feature = "debug")]
     println!();
 
+    let child_count = tree.children[node].len();
+
     // First we check if we have a cached result for the given input
-    let cache_run_mode = if tree.is_childless(node) { RunMode::PeformLayout } else { run_mode };
-    if let Some(cached_size_and_baselines) =
-        compute_from_cache(tree, node, known_dimensions, available_space, cache_run_mode, sizing_mode)
-    {
+    let cache_run_mode = if child_count == 0 { RunMode::PeformLayout } else { run_mode };
+    let cached_size = tree.nodes[node].cache.get(known_dimensions, available_space, cache_run_mode, sizing_mode);
+    if let Some(cached_size_and_baselines) = cached_size {
         #[cfg(feature = "debug")]
         NODE_LOGGER.labelled_debug_log("CACHE", cached_size_and_baselines.size);
         #[cfg(feature = "debug")]
@@ -156,7 +129,6 @@ fn compute_node_layout(
     #[inline(always)]
     fn perform_computations<Algorithm: LayoutAlgorithm>(
         tree: &mut impl LayoutTree,
-        node: Node,
         known_dimensions: Size<Option<f32>>,
         parent_size: Size<Option<f32>>,
         available_space: Size<AvailableSpace>,
@@ -168,31 +140,32 @@ fn compute_node_layout(
 
         match run_mode {
             RunMode::PeformLayout => {
-                Algorithm::perform_layout(tree, node, known_dimensions, parent_size, available_space, sizing_mode)
+                Algorithm::perform_layout(tree, known_dimensions, parent_size, available_space, sizing_mode)
             }
             RunMode::ComputeSize => {
-                let size =
-                    Algorithm::measure_size(tree, node, known_dimensions, parent_size, available_space, sizing_mode);
+                let size = Algorithm::measure_size(tree, known_dimensions, parent_size, available_space, sizing_mode);
                 SizeAndBaselines { size, first_baselines: Point::NONE }
             }
         }
     }
 
-    let computed_size_and_baselines = if tree.is_childless(node) {
-        perform_computations::<LeafAlgorithm>(
-            tree,
-            node,
-            known_dimensions,
-            parent_size,
-            available_space,
-            run_mode,
-            sizing_mode,
-        )
+    let computed_size_and_baselines = if child_count == 0 {
+        #[cfg(feature = "debug")]
+        NODE_LOGGER.log("LEAF");
+
+        match run_mode {
+            RunMode::PeformLayout => {
+                leaf::perform_layout(tree, node, known_dimensions, parent_size, available_space, sizing_mode)
+            }
+            RunMode::ComputeSize => {
+                let size = leaf::measure_size(tree, node, known_dimensions, parent_size, available_space, sizing_mode);
+                SizeAndBaselines { size, first_baselines: Point::NONE }
+            }
+        }
     } else {
-        match tree.style(node).display {
+        match tree.nodes[node].style.display {
             Display::Flex => perform_computations::<FlexboxAlgorithm>(
-                tree,
-                node,
+                &mut tree.node_ref_mut(node).unwrap(),
                 known_dimensions,
                 parent_size,
                 available_space,
@@ -201,34 +174,27 @@ fn compute_node_layout(
             ),
             #[cfg(feature = "grid")]
             Display::Grid => perform_computations::<CssGridAlgorithm>(
-                tree,
-                node,
-                known_dimensions,
-                parent_size,
-                available_space,
-                run_mode,
-                sizing_mode,
-            ),
-            Display::None => perform_computations::<HiddenAlgorithm>(
-                tree,
-                node,
+                &mut tree.node_ref_mut(node).unwrap(),
                 known_dimensions,
                 parent_size,
                 available_space,
                 run_mode,
                 sizing_mode,
             ),
+            Display::None => {
+                tree.nodes[node].layout = Layout::with_order(0);
+                for index in 0..child_count {
+                    let child_id = tree.children[node][index];
+                    let node_ref = &mut tree.node_ref_mut(node).unwrap();
+                    node_ref.perform_child_hidden_layout(child_id, index as _)
+                }
+                SizeAndBaselines { size: Size::ZERO, first_baselines: Point::NONE }
+            }
         }
     };
 
     // Cache result
-    let cache_slot = compute_cache_slot(known_dimensions, available_space);
-    *tree.cache_mut(node, cache_slot) = Some(Cache {
-        known_dimensions,
-        available_space,
-        run_mode: cache_run_mode,
-        cached_size_and_baselines: computed_size_and_baselines,
-    });
+    tree.nodes[node].cache.store(known_dimensions, available_space, cache_run_mode, computed_size_and_baselines);
 
     #[cfg(feature = "debug")]
     NODE_LOGGER.labelled_debug_log("RESULT", computed_size_and_baselines.size);
@@ -249,199 +215,65 @@ fn debug_log_node(
     NODE_LOGGER.debug_log(run_mode);
     NODE_LOGGER.labelled_debug_log("sizing_mode", sizing_mode);
     NODE_LOGGER.labelled_debug_log("known_dimensions", known_dimensions);
+    NODE_LOGGER.labelled_debug_log("parent_size", parent_size);
     NODE_LOGGER.labelled_debug_log("available_space", available_space);
 }
 
-/// Return the cache slot to cache the current computed result in
-///
-/// ## Caching Strategy
-///
-/// We need multiple cache slots, because a node's size is often queried by it's parent multiple times in the course of the layout
-/// process, and we don't want later results to clobber earlier ones.
-///
-/// The two variables that we care about when determining cache slot are:
-///
-///   - How many "known_dimensions" are set. In the worst case, a node may be called first with neither dimensions known known_dimensions,
-///     then with one dimension known (either width of height - which doesn't matter for our purposes here), and then with both dimensions
-///     known.
-///   - Whether unknown dimensions are being sized under a min-content or a max-content available space constraint (definite available space
-///     shares a cache slot with max-content because a node will generally be sized under one or the other but not both).
-///
-/// ## Cache slots:
-///
-/// - Slot 0: Both known_dimensions were set
-/// - Slot 1: 1 of 2 known_dimensions were set and the other dimension was either a MaxContent or Definite available space constraint
-/// - Slot 2: 1 of 2 known_dimensions were set and the other dimension was a MinContent constraint
-/// - Slot 3: Neither known_dimensions were set and we are sizing under a MaxContent or Definite available space constraint
-/// - Slot 4: Neither known_dimensions were set and we are sizing under a MinContent constraint
-#[inline]
-fn compute_cache_slot(known_dimensions: Size<Option<f32>>, available_space: Size<AvailableSpace>) -> usize {
-    let has_known_width = known_dimensions.width.is_some();
-    let has_known_height = known_dimensions.height.is_some();
-
-    // Slot 0: Both known_dimensions were set
-    if has_known_width && has_known_height {
-        return 0;
-    }
-
-    // Slot 1: width but not height known_dimension was set and the other dimension was either a MaxContent or Definite available space constraint
-    // Slot 2: width but not height known_dimension was set and the other dimension was a MinContent constraint
-    if has_known_width && !has_known_height {
-        return 1 + (available_space.height == AvailableSpace::MinContent) as usize;
-    }
-
-    // Slot 3: height but not width known_dimension was set and the other dimension was either a MaxContent or Definite available space constraint
-    // Slot 4: height but not width known_dimension was set and the other dimension was a MinContent constraint
-    if !has_known_width && has_known_height {
-        return 3 + (available_space.width == AvailableSpace::MinContent) as usize;
-    }
-
-    // Slot 5: Neither known_dimensions were set and we are sizing under a MaxContent or Definite available space constraint
-    // Slot 6: Neither known_dimensions were set and we are sizing under a MinContent constraint
-    5 + (available_space.width == AvailableSpace::MinContent) as usize
-}
-
-/// Try to get the computation result from the cache.
-#[inline]
-fn compute_from_cache(
-    tree: &mut impl LayoutTree,
-    node: Node,
-    known_dimensions: Size<Option<f32>>,
-    available_space: Size<AvailableSpace>,
-    run_mode: RunMode,
-    sizing_mode: SizingMode,
-) -> Option<SizeAndBaselines> {
-    for idx in 0..CACHE_SIZE {
-        let entry = tree.cache_mut(node, idx);
-        if let Some(entry) = entry {
-            // Cached ComputeSize results are not valid if we are running in PerformLayout mode
-            if entry.run_mode == RunMode::ComputeSize && run_mode == RunMode::PeformLayout {
-                return None;
-            }
-
-            let cached_size = entry.cached_size_and_baselines.size;
-
-            if (known_dimensions.width == entry.known_dimensions.width
-                || known_dimensions.width == Some(cached_size.width))
-                && (known_dimensions.height == entry.known_dimensions.height
-                    || known_dimensions.height == Some(cached_size.height))
-                && (known_dimensions.width.is_some()
-                    || entry.available_space.width.is_roughly_equal(available_space.width)
-                    || (sizing_mode == SizingMode::ContentSize
-                        && available_space.width.is_definite()
-                        && available_space.width.unwrap() >= cached_size.width))
-                && (known_dimensions.height.is_some()
-                    || entry.available_space.height.is_roughly_equal(available_space.height)
-                    || (sizing_mode == SizingMode::ContentSize
-                        && available_space.height.is_definite()
-                        && available_space.height.unwrap() >= cached_size.height))
-            {
-                return Some(entry.cached_size_and_baselines);
-            }
-        }
-    }
-
-    None
-}
-
-/// The public interface to Taffy's hidden node algorithm implementation
-struct HiddenAlgorithm;
-impl LayoutAlgorithm for HiddenAlgorithm {
-    const NAME: &'static str = "NONE";
-
-    fn perform_layout(
-        tree: &mut impl LayoutTree,
-        node: Node,
-        _known_dimensions: Size<Option<f32>>,
-        _parent_size: Size<Option<f32>>,
-        _available_space: Size<AvailableSpace>,
-        _sizing_mode: SizingMode,
-    ) -> SizeAndBaselines {
-        perform_hidden_layout(tree, node);
-        SizeAndBaselines { size: Size::ZERO, first_baselines: Point::NONE }
-    }
-
-    fn measure_size(
-        _tree: &mut impl LayoutTree,
-        _node: Node,
-        _known_dimensions: Size<Option<f32>>,
-        _parent_size: Size<Option<f32>>,
-        _available_space: Size<AvailableSpace>,
-        _sizing_mode: SizingMode,
-    ) -> Size<f32> {
-        Size::ZERO
-    }
-}
-
 /// Creates a layout for this node and its children, recursively.
 /// Each hidden node has zero size and is placed at the origin
-fn perform_hidden_layout(tree: &mut impl LayoutTree, node: Node) {
-    /// Recursive function to apply hidden layout to all descendents
-    fn perform_hidden_layout_inner(tree: &mut impl LayoutTree, node: Node, order: u32) {
-        *tree.layout_mut(node) = Layout::with_order(order);
-        for order in 0..tree.child_count(node) {
-            perform_hidden_layout_inner(tree, tree.child(node, order), order as _);
-        }
-    }
-
-    for order in 0..tree.child_count(node) {
-        perform_hidden_layout_inner(tree, tree.child(node, order), order as _);
+pub(crate) fn recursively_perform_hidden_layout(tree: &mut Taffy, node: Node, order: u32) {
+    tree.nodes[node].layout = Layout::with_order(order);
+    for index in 0..tree.children[node].len() {
+        recursively_perform_hidden_layout(tree, tree.children[node][index], index as _);
     }
 }
 
 /// Rounds the calculated [`NodeData`] according to the spec
-fn round_layout(tree: &mut impl LayoutTree, root: Node) {
-    let layout = tree.layout_mut(root);
-
-    layout.location.x = round(layout.location.x);
-    layout.location.y = round(layout.location.y);
-
-    layout.size.width = round(layout.size.width);
-    layout.size.height = round(layout.size.height);
+fn recursively_round_layout(tree: &mut Taffy, node: Node) {
+    tree.nodes[node].layout.round();
 
     // Satisfy the borrow checker here by re-indexing to shorten the lifetime to the loop scope
-    for x in 0..tree.child_count(root) {
-        let child = tree.child(root, x);
-        round_layout(tree, child);
+    for index in 0..tree.children[node].len() {
+        recursively_round_layout(tree, tree.children[node][index]);
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::perform_hidden_layout;
-    use crate::geometry::{Point, Size};
-    use crate::style::{Display, Style};
-    use crate::Taffy;
-
-    #[test]
-    fn hidden_layout_should_hide_recursively() {
-        let mut taffy = Taffy::new();
-
-        let style: Style = Style { display: Display::Flex, size: Size::from_points(50.0, 50.0), ..Default::default() };
-
-        let grandchild_00 = taffy.new_leaf(style.clone()).unwrap();
-        let grandchild_01 = taffy.new_leaf(style.clone()).unwrap();
-        let child_00 = taffy.new_with_children(style.clone(), &[grandchild_00, grandchild_01]).unwrap();
-
-        let grandchild_02 = taffy.new_leaf(style.clone()).unwrap();
-        let child_01 = taffy.new_with_children(style.clone(), &[grandchild_02]).unwrap();
-
-        let root = taffy
-            .new_with_children(
-                Style { display: Display::None, size: Size::from_points(50.0, 50.0), ..Default::default() },
-                &[child_00, child_01],
-            )
-            .unwrap();
-
-        perform_hidden_layout(&mut taffy, root);
-
-        // Whatever size and display-mode the nodes had previously,
-        // all layouts should resolve to ZERO due to the root's DISPLAY::NONE
-        for (node, _) in taffy.nodes.iter().filter(|(node, _)| *node != root) {
-            if let Ok(layout) = taffy.layout(node) {
-                assert_eq!(layout.size, Size::zero());
-                assert_eq!(layout.location, Point::zero());
-            }
-        }
-    }
-}
+// #[cfg(test)]
+// mod tests {
+//     use super::perform_hidden_layout;
+//     use crate::geometry::{Point, Size};
+//     use crate::style::{Display, Style};
+//     use crate::Taffy;
+
+//     #[test]
+//     fn hidden_layout_should_hide_recursively() {
+//         let mut taffy = Taffy::new();
+
+//         let style: Style = Style { display: Display::Flex, size: Size::from_points(50.0, 50.0), ..Default::default() };
+
+//         let grandchild_00 = taffy.new_leaf(style.clone()).unwrap();
+//         let grandchild_01 = taffy.new_leaf(style.clone()).unwrap();
+//         let child_00 = taffy.new_with_children(style.clone(), &[grandchild_00, grandchild_01]).unwrap();
+
+//         let grandchild_02 = taffy.new_leaf(style.clone()).unwrap();
+//         let child_01 = taffy.new_with_children(style.clone(), &[grandchild_02]).unwrap();
+
+//         let root = taffy
+//             .new_with_children(
+//                 Style { display: Display::None, size: Size::from_points(50.0, 50.0), ..Default::default() },
+//                 &[child_00, child_01],
+//             )
+//             .unwrap();
+
+//         perform_hidden_layout(&mut taffy, root);
+
+//         // Whatever size and display-mode the nodes had previously,
+//         // all layouts should resolve to ZERO due to the root's DISPLAY::NONE
+//         for (node, _) in taffy.nodes.iter().filter(|(node, _)| *node != root) {
+//             if let Ok(layout) = taffy.layout(node) {
+//                 assert_eq!(layout.size, Size::zero());
+//                 assert_eq!(layout.location, Point::zero());
+//             }
+//         }
+//     }
+// }
diff --git a/src/data.rs b/src/data.rs
index 03a06c673..ee0f02df6 100644
--- a/src/data.rs
+++ b/src/data.rs
@@ -2,12 +2,10 @@
 //!
 //! Used to compute layout for Taffy trees
 //!
-use crate::layout::{Cache, Layout};
+use crate::cache::Cache;
+use crate::layout::Layout;
 use crate::style::Style;
 
-/// The number of cache entries for each node in the tree
-pub(crate) const CACHE_SIZE: usize = 7;
-
 /// Layout information for a given [`Node`](crate::node::Node)
 ///
 /// Stored in a [`Taffy`].
@@ -20,15 +18,15 @@ pub(crate) struct NodeData {
     /// Should we try and measure this node?
     pub(crate) needs_measure: bool,
 
-    /// The primary cached results of the layout computation
-    pub(crate) size_cache: [Option<Cache>; CACHE_SIZE],
+    /// The cached results of the layout computation
+    pub(crate) cache: Cache,
 }
 
 impl NodeData {
     /// Create the data for a new node
     #[must_use]
     pub const fn new(style: Style) -> Self {
-        Self { style, size_cache: [None; CACHE_SIZE], layout: Layout::new(), needs_measure: false }
+        Self { style, cache: Cache::new(), layout: Layout::new(), needs_measure: false }
     }
 
     /// Marks a node and all of its parents (recursively) as dirty
@@ -36,6 +34,6 @@ impl NodeData {
     /// This clears any cached data and signals that the data must be recomputed.
     #[inline]
     pub fn mark_dirty(&mut self) {
-        self.size_cache = [None; CACHE_SIZE];
+        self.cache.clear();
     }
 }
diff --git a/src/debug.rs b/src/debug.rs
index 991cbc4a2..592377cd5 100644
--- a/src/debug.rs
+++ b/src/debug.rs
@@ -4,19 +4,19 @@ use std::sync::Mutex;
 
 use crate::node::Node;
 use crate::style;
-use crate::tree::LayoutTree;
+use crate::Taffy;
 
 /// Prints a debug representation of the computed layout for a tree of nodes, starting with the passed root node.
-pub fn print_tree(tree: &impl LayoutTree, root: Node) {
+pub fn print_tree(tree: &Taffy, root: Node) {
     println!("TREE");
     print_node(tree, root, false, String::new());
 }
 
-fn print_node(tree: &impl LayoutTree, node: Node, has_sibling: bool, lines_string: String) {
-    let layout = tree.layout(node);
-    let style = tree.style(node);
+fn print_node(tree: &Taffy, node: Node, has_sibling: bool, lines_string: String) {
+    let layout = tree.layout(node).unwrap();
+    let style = tree.style(node).unwrap();
 
-    let num_children = tree.child_count(node);
+    let num_children = tree.child_count(node).unwrap();
 
     let display = match (num_children, style.display) {
         (_, style::Display::None) => "NONE",
@@ -42,7 +42,7 @@ fn print_node(tree: &impl LayoutTree, node: Node, has_sibling: bool, lines_strin
     let new_string = lines_string + bar;
 
     // Recurse into children
-    for (index, child) in tree.children(node).enumerate() {
+    for (index, child) in tree.children(node).unwrap().iter().enumerate() {
         let has_sibling = index < num_children - 1;
         print_node(tree, *child, has_sibling, new_string.clone());
     }
diff --git a/src/layout.rs b/src/layout.rs
index dbadcbcb7..b02dbee60 100644
--- a/src/layout.rs
+++ b/src/layout.rs
@@ -1,7 +1,7 @@
-//! Final and cached data structures that represent the high-level UI layout
+//! Types that are either inputs to or outputs from the layout computation
 
 use crate::geometry::{Point, Size};
-use crate::style::AvailableSpace;
+use crate::sys::round;
 
 /// Whether we are performing a full layout, or we merely need to size the node
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -75,18 +75,12 @@ impl Layout {
     pub const fn with_order(order: u32) -> Self {
         Self { order, size: Size::zero(), location: Point::ZERO }
     }
-}
-
-/// Cached intermediate layout results
-#[derive(Debug, Clone, Copy)]
-pub struct Cache {
-    /// The initial cached size of the node itself
-    pub(crate) known_dimensions: Size<Option<f32>>,
-    /// The initial cached size of the parent's node
-    pub(crate) available_space: Size<AvailableSpace>,
-    /// Whether or not layout should be recomputed
-    pub(crate) run_mode: RunMode,
 
-    /// The cached size and baselines of the item
-    pub(crate) cached_size_and_baselines: SizeAndBaselines,
+    /// Round layout to integer values
+    pub fn round(&mut self) {
+        self.location.x = round(self.location.x);
+        self.location.y = round(self.location.y);
+        self.size.width = round(self.size.width);
+        self.size.height = round(self.size.height);
+    }
 }
diff --git a/src/lib.rs b/src/lib.rs
index eec4cb80c..9a3e2d66d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -19,6 +19,7 @@ extern crate alloc;
 extern crate serde;
 
 pub mod axis;
+pub mod cache;
 #[doc(hidden)]
 pub mod debug;
 pub mod error;
@@ -40,4 +41,7 @@ mod resolve;
 mod sys;
 
 pub use crate::compute::compute_layout;
+pub use crate::compute::flexbox::FlexboxAlgorithm;
+pub use crate::compute::grid::CssGridAlgorithm;
+pub use crate::compute::LayoutAlgorithm;
 pub use crate::node::Taffy;
diff --git a/src/node.rs b/src/node.rs
index 433ea39b8..10dcdd4a8 100644
--- a/src/node.rs
+++ b/src/node.rs
@@ -6,14 +6,15 @@ use slotmap::{DefaultKey, SlotMap, SparseSecondaryMap};
 /// A node in a layout.
 pub type Node = slotmap::DefaultKey;
 
+use crate::compute::{self, recursively_perform_hidden_layout};
 use crate::error::{TaffyError, TaffyResult};
 use crate::geometry::Size;
-use crate::layout::{Cache, Layout};
-use crate::prelude::LayoutTree;
+use crate::layout::Layout;
 use crate::style::{AvailableSpace, Style};
 #[cfg(any(feature = "std", feature = "alloc"))]
 use crate::sys::Box;
 use crate::sys::{new_vec_with_capacity, ChildrenVec, Vec};
+use crate::tree::LayoutTree;
 use crate::{data::NodeData, error};
 
 /// A function type that can be used in a [`MeasureFunc`]
@@ -32,6 +33,18 @@ pub enum MeasureFunc {
     Boxed(Box<dyn Measurable>),
 }
 
+impl MeasureFunc {
+    /// Call the measure function to measure to the node
+    #[inline(always)]
+    pub fn measure(&self, known_dimensions: Size<Option<f32>>, available_space: Size<AvailableSpace>) -> Size<f32> {
+        match self {
+            MeasureFunc::Raw(measure) => measure(known_dimensions, available_space),
+            #[cfg(any(feature = "std", feature = "alloc"))]
+            MeasureFunc::Boxed(measure) => (measure as &dyn Fn(_, _) -> _)(known_dimensions, available_space),
+        }
+    }
+}
+
 /// A tree of UI [`Nodes`](`Node`), suitable for UI layout
 pub struct Taffy {
     /// The [`NodeData`] for each node stored in this tree
@@ -57,66 +70,102 @@ impl Default for Taffy {
     }
 }
 
-impl LayoutTree for Taffy {
-    type ChildIter<'a> = std::slice::Iter<'a, DefaultKey>;
+/// An into the tree that represents a single node
+pub(crate) struct TaffyNodeRef<'tree> {
+    /// A reference to the underlying Taffy tree
+    tree: &'tree mut Taffy,
+    /// The id of the node being referenced
+    node_id: Node,
+}
 
-    fn children(&self, node: Node) -> Self::ChildIter<'_> {
-        self.children[node].iter()
+impl<'tree> TaffyNodeRef<'tree> {
+    /// Create a TaffyNodeRef from a Taffy tree and a node id
+    #[inline(always)]
+    fn new(tree: &mut Taffy, node_id: Node) -> TaffyNodeRef<'_> {
+        TaffyNodeRef { tree, node_id }
     }
 
-    fn child_count(&self, node: Node) -> usize {
-        self.children[node].len()
+    /// Get a reference to the NodeData associated with the current NodeRef
+    #[inline(always)]
+    fn node_data(&self) -> &NodeData {
+        &self.tree.nodes[self.node_id]
     }
 
-    fn is_childless(&self, node: Node) -> bool {
-        self.children[node].is_empty()
+    /// Get a mutable reference to the NodeData associated with the current NodeRef
+    #[inline(always)]
+    fn node_data_mut(&mut self) -> &mut NodeData {
+        &mut self.tree.nodes[self.node_id]
     }
+}
 
-    fn parent(&self, node: Node) -> Option<Node> {
-        self.parents.get(node).copied().flatten()
+impl<'tree> LayoutTree for TaffyNodeRef<'tree> {
+    type ChildId = Node;
+    type ChildIter<'a> = core::iter::Copied<core::slice::Iter<'a, DefaultKey>> where Self: 'a;
+
+    #[inline(always)]
+    fn child_count(&self) -> usize {
+        self.tree.children[self.node_id].len()
     }
 
-    fn style(&self, node: Node) -> &Style {
-        &self.nodes[node].style
+    #[inline(always)]
+    fn children(&self) -> Self::ChildIter<'_> {
+        self.tree.children[self.node_id].iter().copied()
     }
 
-    fn layout(&self, node: Node) -> &Layout {
-        &self.nodes[node].layout
+    #[inline(always)]
+    fn child(&self, index: usize) -> Node {
+        self.tree.children[self.node_id][index]
     }
 
-    fn layout_mut(&mut self, node: Node) -> &mut Layout {
-        &mut self.nodes[node].layout
+    #[inline(always)]
+    fn style(&self) -> &Style {
+        &self.node_data().style
     }
 
     #[inline(always)]
-    fn mark_dirty(&mut self, node: Node) -> TaffyResult<()> {
-        self.mark_dirty_internal(node)
+    fn child_style(&self, child_node_id: Node) -> &Style {
+        &self.tree.nodes[child_node_id].style
     }
 
-    fn measure_node(
-        &self,
-        node: Node,
-        known_dimensions: Size<Option<f32>>,
-        available_space: Size<AvailableSpace>,
-    ) -> Size<f32> {
-        match &self.measure_funcs[node] {
-            MeasureFunc::Raw(measure) => measure(known_dimensions, available_space),
+    #[inline(always)]
+    fn layout_mut(&mut self) -> &mut Layout {
+        &mut self.node_data_mut().layout
+    }
 
-            #[cfg(any(feature = "std", feature = "alloc"))]
-            MeasureFunc::Boxed(measure) => (measure as &dyn Fn(_, _) -> _)(known_dimensions, available_space),
-        }
+    #[inline(always)]
+    fn child_layout_mut(&mut self, child_node_id: Node) -> &mut Layout {
+        &mut self.tree.nodes[child_node_id].layout
     }
 
-    fn needs_measure(&self, node: Node) -> bool {
-        self.nodes[node].needs_measure && self.measure_funcs.get(node).is_some()
+    #[inline(always)]
+    fn measure_child_size(
+        &mut self,
+        child_node_id: Node,
+        known_dimensions: Size<Option<f32>>,
+        parent_size: Size<Option<f32>>,
+        available_space: Size<AvailableSpace>,
+        sizing_mode: crate::layout::SizingMode,
+    ) -> Size<f32> {
+        // let mut tree = TaffyNodeRef::new(self.tree, child_node_id);
+        compute::measure_size(self.tree, child_node_id, known_dimensions, parent_size, available_space, sizing_mode)
     }
 
-    fn cache_mut(&mut self, node: Node, index: usize) -> &mut Option<Cache> {
-        &mut self.nodes[node].size_cache[index]
+    #[inline(always)]
+    fn perform_child_layout(
+        &mut self,
+        child_node_id: Node,
+        known_dimensions: Size<Option<f32>>,
+        parent_size: Size<Option<f32>>,
+        available_space: Size<AvailableSpace>,
+        sizing_mode: crate::layout::SizingMode,
+    ) -> crate::layout::SizeAndBaselines {
+        // let mut tree = TaffyNodeRef::new(self.tree, child_node_id);
+        compute::perform_layout(self.tree, child_node_id, known_dimensions, parent_size, available_space, sizing_mode)
     }
 
-    fn child(&self, node: Node, id: usize) -> Node {
-        self.children[node][id]
+    #[inline(always)]
+    fn perform_child_hidden_layout(&mut self, child_node_id: Node, order: u32) {
+        recursively_perform_hidden_layout(self.tree, child_node_id, order);
     }
 }
 
@@ -216,7 +265,7 @@ impl Taffy {
             self.measure_funcs.remove(node);
         }
 
-        self.mark_dirty_internal(node)?;
+        self.mark_dirty(node)?;
 
         Ok(())
     }
@@ -225,7 +274,7 @@ impl Taffy {
     pub fn add_child(&mut self, parent: Node, child: Node) -> TaffyResult<()> {
         self.parents[child] = Some(parent);
         self.children[parent].push(child);
-        self.mark_dirty_internal(parent)?;
+        self.mark_dirty(parent)?;
 
         Ok(())
     }
@@ -244,7 +293,7 @@ impl Taffy {
 
         self.children[parent] = children.iter().copied().collect::<_>();
 
-        self.mark_dirty_internal(parent)?;
+        self.mark_dirty(parent)?;
 
         Ok(())
     }
@@ -269,7 +318,7 @@ impl Taffy {
         let child = self.children[parent].remove(child_index);
         self.parents[child] = None;
 
-        self.mark_dirty_internal(parent)?;
+        self.mark_dirty(parent)?;
 
         Ok(child)
     }
@@ -287,7 +336,7 @@ impl Taffy {
         let old_child = core::mem::replace(&mut self.children[parent][child_index], new_child);
         self.parents[old_child] = None;
 
-        self.mark_dirty_internal(parent)?;
+        self.mark_dirty(parent)?;
 
         Ok(old_child)
     }
@@ -307,15 +356,29 @@ impl Taffy {
         Ok(self.children[parent].len())
     }
 
+    /// Returns a node ref to the specified node in the tree
+    pub(crate) fn node_ref_mut(&mut self, node: Node) -> TaffyResult<TaffyNodeRef> {
+        if self.nodes.get(node).is_some() {
+            Ok(TaffyNodeRef::new(self, node))
+        } else {
+            Err(error::TaffyError::InvalidInputNode(node))
+        }
+    }
+
     /// Returns a list of children that belong to the parent [`Node`]
     pub fn children(&self, parent: Node) -> TaffyResult<Vec<Node>> {
         Ok(self.children[parent].iter().copied().collect::<_>())
     }
 
+    /// Get any available parent for this node
+    pub fn parent(&self, node: Node) -> Option<Node> {
+        self.parents.get(node).copied().flatten()
+    }
+
     /// Sets the [`Style`] of the provided `node`
     pub fn set_style(&mut self, node: Node, style: Style) -> TaffyResult<()> {
         self.nodes[node].style = style;
-        self.mark_dirty_internal(node)?;
+        self.mark_dirty(node)?;
         Ok(())
     }
 
@@ -334,7 +397,7 @@ impl Taffy {
     /// Performs a recursive depth-first search up the tree until the root node is reached
     ///
     /// WARNING: this will stack-overflow if the tree contains a cycle
-    fn mark_dirty_internal(&mut self, node: Node) -> TaffyResult<()> {
+    pub fn mark_dirty(&mut self, node: Node) -> TaffyResult<()> {
         /// WARNING: this will stack-overflow if the tree contains a cycle
         fn mark_dirty_recursive(
             nodes: &mut SlotMap<Node, NodeData>,
@@ -355,7 +418,7 @@ impl Taffy {
 
     /// Indicates whether the layout of this node (and its children) need to be recomputed
     pub fn dirty(&self, node: Node) -> TaffyResult<bool> {
-        Ok(self.nodes[node].size_cache.iter().all(|entry| entry.is_none()))
+        Ok(self.nodes[node].cache.is_empty())
     }
 
     /// Updates the stored layout of the provided `node` and its children
diff --git a/src/prelude.rs b/src/prelude.rs
index effc57d7c..7a49bc42a 100644
--- a/src/prelude.rs
+++ b/src/prelude.rs
@@ -7,7 +7,6 @@ use crate::layout::{SizeAndBaselines, SizingMode};
 #[inline(always)]
 pub fn layout_flexbox(
     tree: &mut impl LayoutTree,
-    node: Node,
     known_dimensions: Size<Option<f32>>,
     parent_size: Size<Option<f32>>,
     available_space: Size<AvailableSpace>,
@@ -15,7 +14,6 @@ pub fn layout_flexbox(
 ) -> SizeAndBaselines {
     crate::compute::flexbox::FlexboxAlgorithm::perform_layout(
         tree,
-        node,
         known_dimensions,
         parent_size,
         available_space,
diff --git a/src/resolve.rs b/src/resolve.rs
index 0705fa8c2..3d55d4222 100644
--- a/src/resolve.rs
+++ b/src/resolve.rs
@@ -1,6 +1,7 @@
 //! Helper trait to calculate dimensions during layout resolution
 
-use crate::prelude::{Dimension, LengthPercentage, LengthPercentageAuto, Rect, Size};
+use crate::geometry::{Rect, Size};
+use crate::style::{Dimension, LengthPercentage, LengthPercentageAuto};
 use crate::style_helpers::TaffyZero;
 
 /// Trait to encapsulate behaviour where we need to resolve from a
diff --git a/src/tree.rs b/src/tree.rs
index 0a6448a47..ef08803df 100644
--- a/src/tree.rs
+++ b/src/tree.rs
@@ -1,66 +1,70 @@
 //! The baseline requirements of any UI Tree so Taffy can efficiently calculate the layout
 
-use slotmap::DefaultKey;
-
 use crate::{
-    error::TaffyResult,
-    layout::{Cache, Layout},
+    layout::{Layout, SizeAndBaselines, SizingMode},
     prelude::*,
 };
+use core::fmt::Debug;
 
 /// Any item that implements the LayoutTree can be layed out using Taffy's algorithms.
 ///
 /// Generally, Taffy expects your Node tree to be indexable by stable indices. A "stable" index means that the Node's ID
 /// remains the same between re-layouts.
 pub trait LayoutTree {
+    /// Type of an id that represents a child of the current node
+    /// This can be a usize if you are storing children in a vector
+    type ChildId: Copy + PartialEq + Debug;
+
     /// Type representing an iterator of the children of a node
-    type ChildIter<'a>: Iterator<Item = &'a DefaultKey>
+    type ChildIter<'a>: Iterator<Item = Self::ChildId>
     where
         Self: 'a;
 
-    /// Get the list of children IDs for the given node
-    fn children(&self, node: Node) -> Self::ChildIter<'_>;
+    // Current node methods
 
-    /// Get the number of children for the given node
-    fn child_count(&self, node: Node) -> usize;
+    /// Get the [`Style`] for this Node.
+    fn style(&self) -> &Style;
 
-    /// Returns true if the node has no children
-    fn is_childless(&self, node: Node) -> bool;
+    /// Modify the node's output layout
+    fn layout_mut(&mut self) -> &mut Layout;
 
-    /// Get a specific child of a node, where the index represents the nth child
-    fn child(&self, node: Node, index: usize) -> Node;
+    // Child methods
 
-    /// Get any available parent for this node
-    fn parent(&self, node: Node) -> Option<Node>;
+    /// Get the list of children IDs for the given node
+    fn children(&self) -> Self::ChildIter<'_>;
 
-    // todo: allow abstractions over this so we don't prescribe how layout works
-    // for reference, CSS cascades require context, and storing a full flexbox layout for each node could be inefficient
-    //
-    /// Get the [`Style`] for this Node.
-    fn style(&self, node: Node) -> &Style;
+    /// Get the number of children for the given node
+    fn child_count(&self) -> usize;
 
-    /// Get the node's output "Final Layout"
-    fn layout(&self, node: Node) -> &Layout;
+    /// Get a specific child of a node, where the index represents the nth child
+    fn child(&self, index: usize) -> Self::ChildId;
 
-    /// Modify the node's output layout
-    fn layout_mut(&mut self, node: Node) -> &mut Layout;
+    /// Get the [`Style`] for this child.
+    fn child_style(&self, child_node_id: Self::ChildId) -> &Style;
 
-    /// Mark a node as dirty to tell Taffy that something has changed and it needs to be recomputed.
-    ///
-    /// Commonly done if the style of the node has changed.
-    fn mark_dirty(&mut self, node: Node) -> TaffyResult<()>;
+    /// Modify the child's output layout
+    fn child_layout_mut(&mut self, child_node_id: Self::ChildId) -> &mut Layout;
 
-    /// Measure a node. Taffy uses this to force reflows of things like text and overflowing content.
-    fn measure_node(
-        &self,
-        node: Node,
+    /// Compute the size of the node given the specified constraints
+    fn measure_child_size(
+        &mut self,
+        child_node_id: Self::ChildId,
         known_dimensions: Size<Option<f32>>,
+        parent_size: Size<Option<f32>>,
         available_space: Size<AvailableSpace>,
+        sizing_mode: SizingMode,
     ) -> Size<f32>;
 
-    /// Node needs to be measured
-    fn needs_measure(&self, node: Node) -> bool;
+    /// Perform a full layout on the node given the specified constraints
+    fn perform_child_layout(
+        &mut self,
+        child_node_id: Self::ChildId,
+        known_dimensions: Size<Option<f32>>,
+        parent_size: Size<Option<f32>>,
+        available_space: Size<AvailableSpace>,
+        sizing_mode: SizingMode,
+    ) -> SizeAndBaselines;
 
-    /// Get a cache entry for this Node by index
-    fn cache_mut(&mut self, node: Node, index: usize) -> &mut Option<Cache>;
+    /// Perform a hidden layout (mark the node as invisible)
+    fn perform_child_hidden_layout(&mut self, child_node_id: Self::ChildId, order: u32);
 }