diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml
index 671e7fc03..934eba4d3 100644
--- a/.github/workflows/benchmarks.yml
+++ b/.github/workflows/benchmarks.yml
@@ -1,5 +1,5 @@
 on: 
-  push:
+  pull_request:
     paths:
       - 'crates/torin/**/*'
       - '.github/workflows/benchmarks.yml'
@@ -14,5 +14,5 @@ jobs:
       - uses: boa-dev/criterion-compare-action@59f4d964c5f19d7f13d36f5c0944b18ce6652cb0
         with:
           package: torin
-          branchName: feat/torin-benchmarks-TEST-COMPARE
+          branchName: ${{ github.base_ref }}
           token: ${{ secrets.GITHUB_TOKEN }}
\ No newline at end of file
diff --git a/book/src/setup.md b/book/src/setup.md
index 483ead6ae..136373ce6 100644
--- a/book/src/setup.md
+++ b/book/src/setup.md
@@ -15,6 +15,13 @@ Install these packages:
 sudo apt install build-essential libssl-dev pkg-config cmake libgtk-3-dev libclang-dev
 ```
 
+#### Arch Linux
+
+Install these packages:
+```sh
+sudo pacman -S base-devel openssl cmake gtk3 clang
+```
+
 Don't hesitate to contribute so other distros can be added here.
 
 ### MacOS
diff --git a/crates/components/Cargo.toml b/crates/components/Cargo.toml
index f75303dcb..8c6d2eeca 100644
--- a/crates/components/Cargo.toml
+++ b/crates/components/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "freya-components"
 description = "Components library desgined for Freya."
-version = "0.1.4"
+version = "0.1.5"
 edition = "2021"
 license = "MIT"
 authors = ["Marc Espín <mespinsanz@gmail.com>"]
diff --git a/crates/core/src/layout.rs b/crates/core/src/layout.rs
index 0f7b3ec95..9be7bbc19 100644
--- a/crates/core/src/layout.rs
+++ b/crates/core/src/layout.rs
@@ -13,17 +13,17 @@ pub fn process_layout(
     scale_factor: f32,
 ) -> (Layers, ViewportsCollection) {
     let rdom = fdom.rdom();
-    let dom_adapter = DioxusDOMAdapter::new(rdom);
+    let mut dom_adapter = DioxusDOMAdapter::new_with_cache(rdom);
     let skia_measurer = SkiaMeasurer::new(rdom, font_collection);
 
     // Finds the best Node from where to start measuring
-    fdom.layout().find_best_root(&dom_adapter);
+    fdom.layout().find_best_root(&mut dom_adapter);
 
     let root_id = fdom.rdom().root_id();
 
     // Measure the layout
     fdom.layout()
-        .measure(root_id, area, &mut Some(skia_measurer), &dom_adapter);
+        .measure(root_id, area, &mut Some(skia_measurer), &mut dom_adapter);
 
     // Create the layers
     let mut layers = Layers::default();
diff --git a/crates/core/src/viewports.rs b/crates/core/src/viewports.rs
index 6bf5240d1..3417314b1 100644
--- a/crates/core/src/viewports.rs
+++ b/crates/core/src/viewports.rs
@@ -26,10 +26,11 @@ pub fn calculate_viewports(
             let node_areas = layout.get(*node_id);
 
             if let Some((node, node_areas)) = node.zip(node_areas) {
-                let style = node.get::<Style>().unwrap();
                 let node_type = &*node.node_type();
 
                 if let NodeType::Element(..) = node_type {
+                    let style = node.get::<Style>().unwrap();
+
                     // Clip any overflow from it's children
                     if style.overflow == OverflowMode::Clip {
                         viewports_collection
@@ -38,14 +39,16 @@ pub fn calculate_viewports(
                             .0 = Some(node_areas.area);
                     }
 
-                    for child in node.children() {
-                        if viewports_collection.contains_key(node_id) {
-                            let mut inherited_viewports =
-                                viewports_collection.get(node_id).unwrap().1.clone();
-
-                            inherited_viewports.push(*node_id);
+                    // Pass viewports to the children
+                    if let Some((_, mut inherited_viewports)) =
+                        viewports_collection.get(node_id).cloned()
+                    {
+                        // Add the itself
+                        inherited_viewports.push(*node_id);
 
-                            viewports_collection.insert(child.id(), (None, inherited_viewports));
+                        for child in node.children() {
+                            viewports_collection
+                                .insert(child.id(), (None, inherited_viewports.clone()));
                         }
                     }
                 }
diff --git a/crates/dom/Cargo.toml b/crates/dom/Cargo.toml
index 3dd49632d..1e8c41bc5 100644
--- a/crates/dom/Cargo.toml
+++ b/crates/dom/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "freya-dom"
 description = "Internal DOM abstractions for Freya."
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 license = "MIT"
 authors = ["Marc Espín <mespinsanz@gmail.com>"]
@@ -11,12 +11,17 @@ repository = "https://github.com/marc2332/freya"
 keywords = ["gui", "ui", "desktop", "skia", "dioxus"]
 categories = ["gui", "asynchronous"]
 
+[package.metadata.docs.rs]
+features = ["freya-engine/mocked-engine"]
+
 [features]
 shared = []
+skia-engine = ["freya-engine/skia-engine"]
 
 [dependencies]
 freya-node-state = { workspace = true }
 freya-common = { workspace = true }
+freya-engine = { workspace = true }
 torin = { workspace = true }
 
 dioxus-rsx = { workspace = true }
diff --git a/crates/dom/src/dom.rs b/crates/dom/src/dom.rs
index 535e2560a..4d0a1391c 100644
--- a/crates/dom/src/dom.rs
+++ b/crates/dom/src/dom.rs
@@ -123,10 +123,10 @@ impl FreyaDOM {
 
     /// Process the given mutations from the [`VirtualDOM`](dioxus_core::VirtualDom).
     pub fn apply_mutations(&mut self, mutations: Mutations, scale_factor: f32) -> (bool, bool) {
-        let dom_adapter = DioxusDOMAdapter::new(self.rdom());
+        let mut dom_adapter = DioxusDOMAdapter::new_with_cache(self.rdom());
         // Apply the mutations to the layout
         self.layout()
-            .apply_mutations(&mutations, &self.dioxus_integration_state, &dom_adapter);
+            .apply_mutations(&mutations, &self.dioxus_integration_state, &mut dom_adapter);
 
         // Apply the mutations the integration state
         self.dioxus_integration_state
diff --git a/crates/dom/src/dom_adapter.rs b/crates/dom/src/dom_adapter.rs
index 6903298c5..e97279bb4 100644
--- a/crates/dom/src/dom_adapter.rs
+++ b/crates/dom/src/dom_adapter.rs
@@ -1,5 +1,6 @@
 use dioxus_native_core::{prelude::NodeType, real_dom::NodeImmutable, tree::TreeRef, NodeId};
 use freya_node_state::LayoutState;
+use rustc_hash::FxHashMap;
 use torin::prelude::*;
 
 use crate::dom::DioxusDOM;
@@ -7,11 +8,23 @@ use crate::dom::DioxusDOM;
 /// RealDOM adapter for Torin.
 pub struct DioxusDOMAdapter<'a> {
     pub rdom: &'a DioxusDOM,
+
+    valid_nodes_cache: Option<FxHashMap<NodeId, bool>>,
 }
 
 impl<'a> DioxusDOMAdapter<'a> {
     pub fn new(rdom: &'a DioxusDOM) -> Self {
-        Self { rdom }
+        Self {
+            rdom,
+            valid_nodes_cache: None,
+        }
+    }
+
+    pub fn new_with_cache(rdom: &'a DioxusDOM) -> Self {
+        Self {
+            rdom,
+            valid_nodes_cache: Some(FxHashMap::default()),
+        }
     }
 }
 
@@ -51,17 +64,17 @@ impl DOMAdapter<NodeId> for DioxusDOMAdapter<'_> {
         self.rdom.tree_ref().parent_id(*node_id)
     }
 
-    fn children_of(&self, node_id: &NodeId) -> Vec<NodeId> {
+    fn children_of(&mut self, node_id: &NodeId) -> Vec<NodeId> {
         self.rdom
             .tree_ref()
             .children_ids(*node_id)
             .into_iter()
-            .filter(|id| is_node_valid(self.rdom, id))
+            .filter(|id| is_node_valid(self.rdom, &mut self.valid_nodes_cache, id))
             .collect::<Vec<NodeId>>()
     }
 
-    fn is_node_valid(&self, node_id: &NodeId) -> bool {
-        is_node_valid(self.rdom, node_id)
+    fn is_node_valid(&mut self, node_id: &NodeId) -> bool {
+        is_node_valid(self.rdom, &mut self.valid_nodes_cache, node_id)
     }
 
     fn closest_common_parent(&self, node_id_a: &NodeId, node_id_b: &NodeId) -> Option<NodeId> {
@@ -134,38 +147,58 @@ fn find_common_parent(rdom: &DioxusDOM, node_a: NodeId, node_b: NodeId) -> Optio
 }
 
 /// Check is the given Node is valid or not, this means not being a placeholder or an unconnected Node.
-fn is_node_valid(rdom: &DioxusDOM, node_id: &NodeId) -> bool {
+fn is_node_valid(
+    rdom: &DioxusDOM,
+    valid_nodes_cache: &mut Option<FxHashMap<NodeId, bool>>,
+    node_id: &NodeId,
+) -> bool {
+    // Check if Node was valid from cache
+    if let Some(valid_nodes_cache) = valid_nodes_cache {
+        if let Some(is_valid) = valid_nodes_cache.get(node_id) {
+            return *is_valid;
+        }
+    }
+
     let node = rdom.get(*node_id);
 
-    if let Some(node) = node {
-        let is_placeholder = matches!(*node.node_type(), NodeType::Placeholder);
+    let is_valid = 'validation: {
+        if let Some(node) = node {
+            let is_placeholder = matches!(*node.node_type(), NodeType::Placeholder);
 
-        // Placeholders can't be measured
-        if is_placeholder {
-            return false;
-        }
+            // Placeholders can't be measured
+            if is_placeholder {
+                break 'validation false;
+            }
 
-        // Make sure this Node isn't part of an unconnected Node
-        // This walkes up to the ancestor that has a height of 0 and checks if it has the same ID as the root Node
-        // If it has the same ID, it means that is not an unconnected ID, otherwise, it is and should be skipped.
-        let tree = rdom.tree_ref();
-        let mut current = *node_id;
-        loop {
-            let height = tree.height(current);
-            if let Some(height) = height {
-                if height == 0 {
-                    break;
+            // Make sure this Node isn't part of an unconnected Node
+            // This walkes up to the ancestor that has a height of 0 and checks if it has the same ID as the root Node
+            // If it has the same ID, it means that is not an unconnected ID, otherwise, it is and should be skipped.
+            let tree = rdom.tree_ref();
+            let mut current = *node_id;
+            loop {
+                let height = tree.height(current);
+                if let Some(height) = height {
+                    if height == 0 {
+                        break;
+                    }
                 }
-            }
 
-            let parent_current = tree.parent_id(current);
-            if let Some(parent_current) = parent_current {
-                current = parent_current;
+                let parent_current = tree.parent_id(current);
+                if let Some(parent_current) = parent_current {
+                    current = parent_current;
+                }
             }
+
+            current == rdom.root_id()
+        } else {
+            false
         }
+    };
 
-        current == rdom.root_id()
-    } else {
-        false
+    // Save the validation result in the cache
+    if let Some(valid_nodes_cache) = valid_nodes_cache {
+        valid_nodes_cache.insert(*node_id, is_valid);
     }
+
+    is_valid
 }
diff --git a/crates/renderer/Cargo.toml b/crates/renderer/Cargo.toml
index 8835f0c98..99d2e9856 100644
--- a/crates/renderer/Cargo.toml
+++ b/crates/renderer/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "freya-renderer"
 description = "Internal renderer powered by Skia for Freya."
-version = "0.1.5"
+version = "0.1.6"
 edition = "2021"
 license = "MIT"
 authors = ["Marc Espín <mespinsanz@gmail.com>"]
diff --git a/crates/torin/benches/bench.rs b/crates/torin/benches/bench.rs
index 2092659fa..55c3efcbc 100644
--- a/crates/torin/benches/bench.rs
+++ b/crates/torin/benches/bench.rs
@@ -1,291 +1,397 @@
-use std::collections::HashMap;
-
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-use torin::prelude::*;
-
-struct TestingMeasurer;
-
-impl LayoutMeasurer<usize> for TestingMeasurer {
-    fn measure(
-        &mut self,
-        _node_id: usize,
-        _node: &Node,
-        _area: &Area,
-        _parent_size: &Area,
-        _available_parent_area: &Area,
-    ) -> Option<Area> {
-        None
-    }
-}
-
-#[derive(Default)]
-struct TestingDOM {
-    mapper: HashMap<usize, (Option<usize>, Vec<usize>, u16, Node)>,
-}
-
-impl TestingDOM {
-    fn add(&mut self, node_id: usize, parent: Option<usize>, children: Vec<usize>, node: Node) {
-        let depth = parent.map(|p| self.mapper.get(&p).unwrap().2).unwrap_or(0) + 1;
-        self.mapper.insert(node_id, (parent, children, depth, node));
-    }
-
-    fn set_node(&mut self, node_id: usize, node: Node) {
-        self.mapper.get_mut(&node_id).unwrap().3 = node;
-    }
-}
-
-impl DOMAdapter<usize> for TestingDOM {
-    fn children_of(&self, node_id: &usize) -> Vec<usize> {
-        self.mapper
-            .get(node_id)
-            .map(|c| c.1.clone())
-            .unwrap_or_default()
-    }
-
-    fn parent_of(&self, node_id: &usize) -> Option<usize> {
-        self.mapper.get(node_id).map(|c| c.0).flatten()
-    }
-
-    fn height(&self, node_id: &usize) -> Option<u16> {
-        self.mapper.get(node_id).map(|c| c.2)
-    }
-
-    fn get_node(&self, node_id: &usize) -> Option<Node> {
-        self.mapper.get(node_id).map(|c| c.3.clone())
-    }
-
-    fn is_node_valid(&self, _node_id: &usize) -> bool {
-        true
-    }
-
-    fn closest_common_parent(&self, node_id_a: &usize, _node_id_b: &usize) -> Option<usize> {
-        Some(self.parent_of(node_id_a)?)
-    }
-}
-
-fn criterion_benchmark(c: &mut Criterion) {
-    let mut g = c.benchmark_group("benchmarks");
-    g.significance_level(0.1).sample_size(500);
-
-    let params = [
-        ("big trees (wide) nodes=1000, depth=1", 1000, 1),
-        ("big trees (wide) nodes=10000, depth=1", 10000, 1),
-        ("big trees (wide) nodes=100000, depth=1", 100000, 1),
-        ("big trees (deep) nodes=4000, depth=12", 4000, 12),
-        ("big trees (deep) nodes=10000, depth=14", 10000, 14),
-        ("big trees (deep) nodes=100000, depth=17", 100000, 17),
-    ];
-
-    for (name, size, depth) in params {
-        let size_per_layer = size / depth;
-
-        g.bench_function(name, |b| {
-            let mut measurer = Some(TestingMeasurer);
-            let mut mocked_dom = TestingDOM::default();
-
-            let children_ids = (1..=size_per_layer).into_iter().collect::<Vec<usize>>();
-
-            let mut root = 0;
-
-            mocked_dom.add(
-                0,
-                None,
-                children_ids.clone(),
-                Node::from_size_and_direction(
-                    Size::Percentage(Length::new(100.0)),
-                    Size::Percentage(Length::new(100.0)),
-                    DirectionMode::Vertical,
-                ),
-            );
-
-            for level in 0..depth {
-                for i in &children_ids {
-                    let id = (level * size) + *i;
-
-                    mocked_dom.add(
-                        id,
-                        Some(root),
-                        vec![],
-                        Node::from_size_and_direction(
-                            Size::Pixels(Length::new(100.0)),
-                            Size::Pixels(Length::new(100.0)),
-                            DirectionMode::Vertical,
-                        ),
-                    );
-
-                    if *i == size_per_layer - 1 {
-                        root = id
-                    }
-                }
-            }
-
-            b.iter(|| {
-                black_box({
-                    let mut layout = Torin::<usize>::new();
-                    layout.find_best_root(&mocked_dom);
-                    layout.measure(
-                        0,
-                        Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
-                        &mut measurer,
-                        &mocked_dom,
-                    )
-                });
-            })
-        });
-    }
-
-    g.bench_function(
-        "big trees (deep + cached) + invalidated node in the top",
-        |b| {
-            let mut layout = Torin::<usize>::new();
-            let mut measurer = Some(TestingMeasurer);
-            let mut mocked_dom = TestingDOM::default();
-
-            let children_ids = (1..=101).into_iter().collect::<Vec<usize>>();
-
-            let mut root = 0;
-
-            mocked_dom.add(
-                0,
-                None,
-                children_ids.clone(),
-                Node::from_size_and_direction(
-                    Size::Percentage(Length::new(100.0)),
-                    Size::Percentage(Length::new(100.0)),
-                    DirectionMode::Vertical,
-                ),
-            );
-
-            let levels = 20;
-
-            for level in 0..levels {
-                for i in &children_ids {
-                    let id = (level * 1000) + *i;
-
-                    mocked_dom.add(
-                        id,
-                        Some(root),
-                        vec![],
-                        Node::from_size_and_direction(
-                            Size::Pixels(Length::new(100.0)),
-                            Size::Pixels(Length::new(100.0)),
-                            DirectionMode::Vertical,
-                        ),
-                    );
-
-                    if *i == 101 {
-                        root = id
-                    }
-                }
-            }
-
-            layout.find_best_root(&mocked_dom);
-            layout.measure(
-                0,
-                Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
-                &mut measurer,
-                &mocked_dom,
-            );
-
-            b.iter(|| {
-                black_box({
-                    mocked_dom.set_node(
-                        1,
-                        Node::from_size_and_direction(
-                            Size::Inner,
-                            Size::Pixels(Length::new(10.0)),
-                            DirectionMode::Vertical,
-                        ),
-                    );
-                    layout.invalidate(1);
-                    layout.find_best_root(&mocked_dom);
-                    layout.measure(
-                        0,
-                        Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
-                        &mut measurer,
-                        &mocked_dom,
-                    )
-                });
-            })
-        },
-    );
-
-    g.bench_function(
-        "big trees (deep + cached) + invalidated node in the bottom",
-        |b| {
-            let mut layout = Torin::<usize>::new();
-            let mut measurer = Some(TestingMeasurer);
-            let mut mocked_dom = TestingDOM::default();
-
-            let children_ids = (1..=101).into_iter().collect::<Vec<usize>>();
-
-            let mut root = 0;
-
-            mocked_dom.add(
-                0,
-                None,
-                children_ids.clone(),
-                Node::from_size_and_direction(
-                    Size::Percentage(Length::new(100.0)),
-                    Size::Percentage(Length::new(100.0)),
-                    DirectionMode::Vertical,
-                ),
-            );
-
-            let levels = 20;
-
-            for level in 0..levels {
-                for i in &children_ids {
-                    let id = (level * 1000) + *i;
-
-                    mocked_dom.add(
-                        id,
-                        Some(root),
-                        vec![],
-                        Node::from_size_and_direction(
-                            Size::Pixels(Length::new(100.0)),
-                            Size::Pixels(Length::new(100.0)),
-                            DirectionMode::Vertical,
-                        ),
-                    );
-
-                    if *i == 101 {
-                        root = id
-                    }
-                }
-            }
-
-            layout.find_best_root(&mocked_dom);
-            layout.measure(
-                0,
-                Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
-                &mut measurer,
-                &mocked_dom,
-            );
-
-            b.iter(|| {
-                black_box({
-                    mocked_dom.set_node(
-                        1,
-                        Node::from_size_and_direction(
-                            Size::Inner,
-                            Size::Pixels(Length::new(10.0)),
-                            DirectionMode::Vertical,
-                        ),
-                    );
-                    layout.invalidate(2001);
-                    layout.find_best_root(&mocked_dom);
-                    layout.measure(
-                        0,
-                        Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
-                        &mut measurer,
-                        &mocked_dom,
-                    )
-                });
-            })
-        },
-    );
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);
+use std::collections::HashMap;
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use torin::prelude::*;
+
+struct TestingMeasurer;
+
+impl LayoutMeasurer<usize> for TestingMeasurer {
+    fn measure(
+        &mut self,
+        _node_id: usize,
+        _node: &Node,
+        _area: &Area,
+        _parent_size: &Area,
+        _available_parent_area: &Area,
+    ) -> Option<Area> {
+        None
+    }
+}
+
+#[derive(Default)]
+struct TestingDOM {
+    mapper: HashMap<usize, (Option<usize>, Vec<usize>, u16, Node)>,
+}
+
+impl TestingDOM {
+    fn add(&mut self, node_id: usize, parent: Option<usize>, children: Vec<usize>, node: Node) {
+        let depth = parent.map(|p| self.mapper.get(&p).unwrap().2).unwrap_or(0) + 1;
+        self.mapper.insert(node_id, (parent, children, depth, node));
+    }
+
+    fn set_node(&mut self, node_id: usize, node: Node) {
+        self.mapper.get_mut(&node_id).unwrap().3 = node;
+    }
+}
+
+impl DOMAdapter<usize> for TestingDOM {
+    fn children_of(&mut self, node_id: &usize) -> Vec<usize> {
+        self.mapper
+            .get(node_id)
+            .map(|c| c.1.clone())
+            .unwrap_or_default()
+    }
+
+    fn parent_of(&self, node_id: &usize) -> Option<usize> {
+        self.mapper.get(node_id).map(|c| c.0).flatten()
+    }
+
+    fn height(&self, node_id: &usize) -> Option<u16> {
+        self.mapper.get(node_id).map(|c| c.2)
+    }
+
+    fn get_node(&self, node_id: &usize) -> Option<Node> {
+        self.mapper.get(node_id).map(|c| c.3.clone())
+    }
+
+    fn is_node_valid(&mut self, _node_id: &usize) -> bool {
+        true
+    }
+
+    fn closest_common_parent(&self, node_id_a: &usize, _node_id_b: &usize) -> Option<usize> {
+        Some(self.parent_of(node_id_a)?)
+    }
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut g = c.benchmark_group("benchmarks");
+    g.significance_level(0.1).sample_size(500);
+
+    let params = [
+        ("big trees (wide) nodes=1000, depth=1", 1000, 1),
+        ("big trees (wide) nodes=10000, depth=1", 10000, 1),
+        ("big trees (wide) nodes=100000, depth=1", 100000, 1),
+        ("big trees (deep) nodes=4000, depth=12", 4000, 12),
+        ("big trees (deep) nodes=10000, depth=14", 10000, 14),
+        ("big trees (deep) nodes=100000, depth=17", 100000, 17),
+    ];
+
+    for (name, size, depth) in params {
+        let size_per_layer = size / depth;
+
+        g.bench_function(name, |b| {
+            let mut measurer = Some(TestingMeasurer);
+            let mut mocked_dom = TestingDOM::default();
+
+            let children_ids = (1..=size_per_layer).into_iter().collect::<Vec<usize>>();
+
+            let mut root = 0;
+
+            mocked_dom.add(
+                0,
+                None,
+                children_ids.clone(),
+                Node::from_size_and_direction(
+                    Size::Percentage(Length::new(100.0)),
+                    Size::Percentage(Length::new(100.0)),
+                    DirectionMode::Vertical,
+                ),
+            );
+
+            for level in 0..depth {
+                for i in &children_ids {
+                    let id = (level * size) + *i;
+                    let children = if level == depth - 1 {
+                        vec![]
+                    } else if *i == size_per_layer - 1 {
+                        (1..101)
+                            .map(move |i| i + ((level + 1) * size))
+                            .collect::<Vec<usize>>()
+                    } else {
+                        vec![]
+                    };
+
+                    mocked_dom.add(
+                        id,
+                        Some(root),
+                        children,
+                        Node::from_size_and_direction(
+                            Size::Pixels(Length::new(100.0)),
+                            Size::Pixels(Length::new(100.0)),
+                            DirectionMode::Vertical,
+                        ),
+                    );
+
+                    if *i == size_per_layer - 1 {
+                        root = id
+                    }
+                }
+            }
+
+            b.iter(|| {
+                black_box({
+                    let mut layout = Torin::<usize>::new();
+                    layout.find_best_root(&mut mocked_dom);
+                    layout.measure(
+                        0,
+                        Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
+                        &mut measurer,
+                        &mut mocked_dom,
+                    )
+                });
+            })
+        });
+    }
+
+    g.bench_function(
+        "big trees (deep + cached) + invalidated node in the top",
+        |b| {
+            let mut layout = Torin::<usize>::new();
+            let mut measurer = Some(TestingMeasurer);
+            let mut mocked_dom = TestingDOM::default();
+
+            let children_ids = (1..=101).into_iter().collect::<Vec<usize>>();
+
+            let mut root = 0;
+
+            mocked_dom.add(
+                0,
+                None,
+                children_ids.clone(),
+                Node::from_size_and_direction(
+                    Size::Percentage(Length::new(100.0)),
+                    Size::Percentage(Length::new(100.0)),
+                    DirectionMode::Vertical,
+                ),
+            );
+
+            let levels = 20;
+
+            for level in 0..levels {
+                for i in &children_ids {
+                    let id = (level * 1000) + *i;
+                    let children = if *i == 101 && level < levels - 1 {
+                        (1..101)
+                            .map(move |i| i + ((level + 1) * 1000))
+                            .collect::<Vec<usize>>()
+                    } else {
+                        vec![]
+                    };
+
+                    mocked_dom.add(
+                        id,
+                        Some(root),
+                        children,
+                        Node::from_size_and_direction(
+                            Size::Pixels(Length::new(100.0)),
+                            Size::Pixels(Length::new(100.0)),
+                            DirectionMode::Vertical,
+                        ),
+                    );
+
+                    if *i == 101 {
+                        root = id
+                    }
+                }
+            }
+
+            layout.find_best_root(&mut mocked_dom);
+            layout.measure(
+                0,
+                Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
+                &mut measurer,
+                &mut mocked_dom,
+            );
+
+            b.iter(|| {
+                black_box({
+                    mocked_dom.set_node(
+                        1,
+                        Node::from_size_and_direction(
+                            Size::Inner,
+                            Size::Pixels(Length::new(10.0)),
+                            DirectionMode::Vertical,
+                        ),
+                    );
+                    layout.invalidate(1);
+                    layout.find_best_root(&mut mocked_dom);
+                    layout.measure(
+                        0,
+                        Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
+                        &mut measurer,
+                        &mut mocked_dom,
+                    )
+                });
+            })
+        },
+    );
+
+    g.bench_function(
+        "big trees (deep + cached) + invalidated node in the bottom",
+        |b| {
+            let mut layout = Torin::<usize>::new();
+            let mut measurer = Some(TestingMeasurer);
+            let mut mocked_dom = TestingDOM::default();
+
+            let children_ids = (1..=101).into_iter().collect::<Vec<usize>>();
+
+            let mut root = 0;
+
+            mocked_dom.add(
+                0,
+                None,
+                children_ids.clone(),
+                Node::from_size_and_direction(
+                    Size::Percentage(Length::new(100.0)),
+                    Size::Percentage(Length::new(100.0)),
+                    DirectionMode::Vertical,
+                ),
+            );
+
+            let levels = 20;
+
+            for level in 0..levels {
+                for i in &children_ids {
+                    let id = (level * 1000) + *i;
+                    let children = if *i == 101 && level < levels - 1 {
+                        (1..101)
+                            .map(move |i| i + ((level + 1) * 1000))
+                            .collect::<Vec<usize>>()
+                    } else {
+                        vec![]
+                    };
+
+                    mocked_dom.add(
+                        id,
+                        Some(root),
+                        children,
+                        Node::from_size_and_direction(
+                            Size::Pixels(Length::new(100.0)),
+                            Size::Pixels(Length::new(100.0)),
+                            DirectionMode::Vertical,
+                        ),
+                    );
+
+                    if *i == 101 {
+                        root = id
+                    }
+                }
+            }
+
+            layout.find_best_root(&mut mocked_dom);
+            layout.measure(
+                0,
+                Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
+                &mut measurer,
+                &mut mocked_dom,
+            );
+
+            b.iter(|| {
+                black_box({
+                    mocked_dom.set_node(
+                        1,
+                        Node::from_size_and_direction(
+                            Size::Inner,
+                            Size::Pixels(Length::new(10.0)),
+                            DirectionMode::Vertical,
+                        ),
+                    );
+                    layout.invalidate(2001);
+                    layout.find_best_root(&mut mocked_dom);
+                    layout.measure(
+                        0,
+                        Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
+                        &mut measurer,
+                        &mut mocked_dom,
+                    )
+                });
+            })
+        },
+    );
+
+    g.bench_function(
+        "big trees (deep + cached) + invalidated node in the middle",
+        |b| {
+            let mut layout = Torin::<usize>::new();
+            let mut measurer = Some(TestingMeasurer);
+            let mut mocked_dom = TestingDOM::default();
+
+            let children_ids = (1..=101).into_iter().collect::<Vec<usize>>();
+
+            let mut root = 0;
+
+            mocked_dom.add(
+                0,
+                None,
+                children_ids.clone(),
+                Node::from_size_and_direction(
+                    Size::Percentage(Length::new(100.0)),
+                    Size::Percentage(Length::new(100.0)),
+                    DirectionMode::Vertical,
+                ),
+            );
+
+            let levels = 20;
+
+            for level in 0..levels {
+                for i in &children_ids {
+                    let id = (level * 1000) + *i;
+                    let children = if *i == 101 && level < levels - 1 {
+                        (1..101)
+                            .map(move |i| i + ((level + 1) * 1000))
+                            .collect::<Vec<usize>>()
+                    } else {
+                        vec![]
+                    };
+
+                    mocked_dom.add(
+                        id,
+                        Some(root),
+                        children,
+                        Node::from_size_and_direction(
+                            Size::Pixels(Length::new(100.0)),
+                            Size::Pixels(Length::new(100.0)),
+                            DirectionMode::Vertical,
+                        ),
+                    );
+
+                    if *i == 101 {
+                        root = id
+                    }
+                }
+            }
+
+            layout.find_best_root(&mut mocked_dom);
+            layout.measure(
+                0,
+                Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
+                &mut measurer,
+                &mut mocked_dom,
+            );
+
+            b.iter(|| {
+                black_box({
+                    mocked_dom.set_node(
+                        1,
+                        Node::from_size_and_direction(
+                            Size::Inner,
+                            Size::Pixels(Length::new(10.0)),
+                            DirectionMode::Vertical,
+                        ),
+                    );
+                    layout.invalidate(1001);
+                    layout.find_best_root(&mut mocked_dom);
+                    layout.measure(
+                        0,
+                        Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
+                        &mut measurer,
+                        &mut mocked_dom,
+                    )
+                });
+            })
+        },
+    );
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/crates/torin/src/dom_adapter.rs b/crates/torin/src/dom_adapter.rs
index a9e0111ae..965a24c4d 100644
--- a/crates/torin/src/dom_adapter.rs
+++ b/crates/torin/src/dom_adapter.rs
@@ -47,10 +47,10 @@ pub trait DOMAdapter<NodeKey> {
     fn parent_of(&self, node_id: &NodeKey) -> Option<NodeKey>;
 
     /// Get the children of a Node
-    fn children_of(&self, node_id: &NodeKey) -> Vec<NodeKey>;
+    fn children_of(&mut self, node_id: &NodeKey) -> Vec<NodeKey>;
 
     /// Check whether the given Node is valid (isn't a placeholder, unconnected node..)
-    fn is_node_valid(&self, node_id: &NodeKey) -> bool;
+    fn is_node_valid(&mut self, node_id: &NodeKey) -> bool;
 
     /// Get the closest common parent Node of two Nodes
     fn closest_common_parent(&self, node_id_a: &NodeKey, node_id_b: &NodeKey) -> Option<NodeKey>;
diff --git a/crates/torin/src/torin.rs b/crates/torin/src/torin.rs
index 3aa8204eb..121c9ff3f 100644
--- a/crates/torin/src/torin.rs
+++ b/crates/torin/src/torin.rs
@@ -1,7 +1,7 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
 pub use euclid::Rect;
-use fxhash::FxHashMap;
+use fxhash::{FxHashMap, FxHashSet};
 use tracing::info;
 
 use crate::{
@@ -30,7 +30,7 @@ pub struct Torin<Key: NodeKey> {
     pub results: FxHashMap<Key, NodeAreas>,
 
     /// Invalid registered nodes since previous layout measurement
-    pub dirty: HashSet<Key>,
+    pub dirty: FxHashSet<Key>,
 
     /// Best Root node candidate from where to start measuring
     pub root_node_candidate: RootNodeCandidate<Key>,
@@ -53,7 +53,7 @@ impl Torin<NodeId> {
         &mut self,
         mutations: &Mutations,
         dioxus_integration_state: &DioxusState,
-        dom_adapter: &impl DOMAdapter<NodeId>,
+        dom_adapter: &mut impl DOMAdapter<NodeId>,
     ) {
         use dioxus_core::Mutation;
 
@@ -99,7 +99,7 @@ impl<Key: NodeKey> Torin<Key> {
     pub fn new() -> Self {
         Self {
             results: HashMap::default(),
-            dirty: HashSet::new(),
+            dirty: FxHashSet::default(),
             root_node_candidate: RootNodeCandidate::None,
         }
     }
@@ -112,7 +112,7 @@ impl<Key: NodeKey> Torin<Key> {
     }
 
     /// Read the HashSet of dirty nodes
-    pub fn get_dirty_nodes(&self) -> &HashSet<Key> {
+    pub fn get_dirty_nodes(&self) -> &FxHashSet<Key> {
         &self.dirty
     }
 
@@ -131,7 +131,7 @@ impl<Key: NodeKey> Torin<Key> {
     pub fn remove(
         &mut self,
         node_id: Key,
-        dom_adapter: &impl DOMAdapter<Key>,
+        dom_adapter: &mut impl DOMAdapter<Key>,
         invalidate_parent: bool,
     ) {
         // Remove itself
@@ -153,7 +153,7 @@ impl<Key: NodeKey> Torin<Key> {
         self.dirty.insert(node_id);
     }
 
-    pub fn safe_invalidate(&mut self, node_id: Key, dom_adapter: &impl DOMAdapter<Key>) {
+    pub fn safe_invalidate(&mut self, node_id: Key, dom_adapter: &mut impl DOMAdapter<Key>) {
         if dom_adapter.is_node_valid(&node_id) {
             self.invalidate(node_id)
         }
@@ -163,7 +163,7 @@ impl<Key: NodeKey> Torin<Key> {
     pub fn check_dirty_dependants(
         &mut self,
         node_id: Key,
-        dom_adapter: &impl DOMAdapter<Key>,
+        dom_adapter: &mut impl DOMAdapter<Key>,
         ignore: bool,
     ) {
         if (self.dirty.contains(&node_id) && ignore) || !dom_adapter.is_node_valid(&node_id) {
@@ -220,7 +220,7 @@ impl<Key: NodeKey> Torin<Key> {
     }
 
     /// Find the best root Node from where to start measuring
-    pub fn find_best_root(&mut self, dom_adapter: &impl DOMAdapter<Key>) {
+    pub fn find_best_root(&mut self, dom_adapter: &mut impl DOMAdapter<Key>) {
         if self.results.is_empty() {
             return;
         }
@@ -235,7 +235,7 @@ impl<Key: NodeKey> Torin<Key> {
         suggested_root_id: Key,
         suggested_root_area: Area,
         measurer: &mut Option<impl LayoutMeasurer<Key>>,
-        dom_adapter: &impl DOMAdapter<Key>,
+        dom_adapter: &mut impl DOMAdapter<Key>,
     ) {
         // If there are previosuly cached results
         // But no dirty nodes, we can simply skip the measurement
@@ -312,7 +312,7 @@ fn measure_node<Key: NodeKey>(
     available_parent_area: &Area,
     measurer: &mut Option<impl LayoutMeasurer<Key>>,
     must_cache: bool,
-    dom_adapter: &impl DOMAdapter<Key>,
+    dom_adapter: &mut impl DOMAdapter<Key>,
 ) -> (bool, NodeAreas) {
     let must_run = layout.dirty.contains(&node_id) || layout.results.get(&node_id).is_none();
     if must_run {
@@ -491,7 +491,7 @@ fn measure_inner_nodes<Key: NodeKey>(
     measurer: &mut Option<impl LayoutMeasurer<Key>>,
     must_cache: bool,
     mode: &mut MeasureMode,
-    dom_adapter: &impl DOMAdapter<Key>,
+    dom_adapter: &mut impl DOMAdapter<Key>,
 ) {
     let children = dom_adapter.children_of(node_id);
 
diff --git a/crates/torin/tests/test.rs b/crates/torin/tests/test.rs
index 524ef761d..a12172736 100644
--- a/crates/torin/tests/test.rs
+++ b/crates/torin/tests/test.rs
@@ -1,5 +1,6 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 
+use fxhash::FxHashSet;
 use torin::prelude::*;
 
 struct TestingMeasurer;
@@ -49,7 +50,7 @@ impl TestingDOM {
 }
 
 impl DOMAdapter<usize> for TestingDOM {
-    fn children_of(&self, node_id: &usize) -> Vec<usize> {
+    fn children_of(&mut self, node_id: &usize) -> Vec<usize> {
         self.mapper
             .get(node_id)
             .map(|c| c.1.clone())
@@ -68,7 +69,7 @@ impl DOMAdapter<usize> for TestingDOM {
         self.mapper.get(node_id).map(|c| c.3.clone())
     }
 
-    fn is_node_valid(&self, _node_id: &usize) -> bool {
+    fn is_node_valid(&mut self, _node_id: &usize) -> bool {
         true
     }
 
@@ -120,12 +121,12 @@ pub fn root_100per_children_50per50per() {
         ),
     );
 
-    layout.find_best_root(&mocked_dom);
+    layout.find_best_root(&mut mocked_dom);
     layout.measure(
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -180,12 +181,12 @@ pub fn root_200px_children_50per50per() {
         ),
     );
 
-    layout.find_best_root(&mocked_dom);
+    layout.find_best_root(&mut mocked_dom);
     layout.measure(
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -244,7 +245,7 @@ pub fn layout_dirty_nodes() {
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     // CASE 1
@@ -277,7 +278,7 @@ pub fn layout_dirty_nodes() {
     );
     layout.invalidate(2);
 
-    assert_eq!(layout.get_dirty_nodes(), &HashSet::from([2]));
+    assert_eq!(layout.get_dirty_nodes(), &FxHashSet::from_iter([2]));
 
     // CASE 2
     // Same as Case 1 but we make Child A depend on Child A[0]'s size
@@ -292,7 +293,7 @@ pub fn layout_dirty_nodes() {
     );
     layout.invalidate(1);
 
-    assert_eq!(layout.get_dirty_nodes(), &HashSet::from([2, 1]));
+    assert_eq!(layout.get_dirty_nodes(), &FxHashSet::from_iter([2, 1]));
 
     // CASE 3
     // Same as Case 2, but triggers a change in Child A[0]
@@ -307,7 +308,7 @@ pub fn layout_dirty_nodes() {
     );
     layout.invalidate(2);
 
-    assert_eq!(layout.get_dirty_nodes(), &HashSet::from([2, 1]));
+    assert_eq!(layout.get_dirty_nodes(), &FxHashSet::from_iter([2, 1]));
 
     // CASE 4
     // Same as Case 3, but triggers a change in the root
@@ -322,7 +323,7 @@ pub fn layout_dirty_nodes() {
     );
     layout.invalidate(0);
 
-    assert_eq!(layout.get_dirty_nodes(), &HashSet::from([2, 1, 0]));
+    assert_eq!(layout.get_dirty_nodes(), &FxHashSet::from_iter([2, 1, 0]));
 }
 
 #[test]
@@ -365,7 +366,7 @@ pub fn direction() {
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -390,12 +391,12 @@ pub fn direction() {
     );
     layout.invalidate(0);
 
-    layout.find_best_root(&mocked_dom);
+    layout.find_best_root(&mut mocked_dom);
     layout.measure(
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -446,12 +447,12 @@ pub fn scroll() {
         ),
     );
 
-    layout.find_best_root(&mocked_dom);
+    layout.find_best_root(&mut mocked_dom);
     layout.measure(
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -495,7 +496,7 @@ pub fn padding() {
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -534,7 +535,7 @@ pub fn caching() {
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -556,7 +557,7 @@ pub fn caching() {
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -601,7 +602,7 @@ pub fn sibling_increments_area() {
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -661,7 +662,7 @@ pub fn node_removal() {
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -679,19 +680,19 @@ pub fn node_removal() {
         Rect::new(Point2D::new(0.0, 200.0), Size2D::new(200.0, 200.0)),
     );
 
-    layout.remove(2, &mocked_dom, true);
+    layout.remove(2, &mut mocked_dom, true);
 
     mocked_dom.remove(2);
 
-    layout.find_best_root(&mocked_dom);
+    layout.find_best_root(&mut mocked_dom);
 
-    assert_eq!(layout.get_dirty_nodes(), &HashSet::from([1, 3]));
+    assert_eq!(layout.get_dirty_nodes(), &FxHashSet::from_iter([1, 3]));
 
     layout.measure(
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -741,7 +742,7 @@ pub fn display_horizontal() {
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -792,12 +793,12 @@ pub fn display_vertical_with_inner_children() {
         ),
     );
 
-    layout.find_best_root(&mocked_dom);
+    layout.find_best_root(&mut mocked_dom);
     layout.measure(
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -883,12 +884,12 @@ pub fn deep_tree() {
         ),
     );
 
-    layout.find_best_root(&mocked_dom);
+    layout.find_best_root(&mut mocked_dom);
     layout.measure(
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     mocked_dom.set_node(
@@ -901,14 +902,14 @@ pub fn deep_tree() {
     );
     layout.invalidate(4);
 
-    layout.find_best_root(&mocked_dom);
+    layout.find_best_root(&mut mocked_dom);
     assert_eq!(layout.get_root_candidate(), RootNodeCandidate::Valid(4));
 
     layout.measure(
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(layout.get_root_candidate(), RootNodeCandidate::None);
@@ -954,7 +955,7 @@ pub fn stacked() {
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -977,13 +978,13 @@ pub fn stacked() {
     );
     layout.invalidate(2);
 
-    layout.find_best_root(&mocked_dom);
+    layout.find_best_root(&mut mocked_dom);
 
     layout.measure(
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -1033,12 +1034,12 @@ pub fn two_cols_auto() {
         ),
     );
 
-    layout.find_best_root(&mocked_dom);
+    layout.find_best_root(&mut mocked_dom);
     layout.measure(
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(400.0, 400.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     assert_eq!(
@@ -1097,7 +1098,7 @@ pub fn margin() {
         0,
         Rect::new(Point2D::new(0.0, 0.0), Size2D::new(1000.0, 1000.0)),
         &mut measurer,
-        &mocked_dom,
+        &mut mocked_dom,
     );
 
     let node_areas = layout.get(1).unwrap();
diff --git a/examples/push_remove.rs b/examples/push_remove.rs
index 58434aa3b..2b4adcfca 100644
--- a/examples/push_remove.rs
+++ b/examples/push_remove.rs
@@ -11,39 +11,18 @@ fn main() {
 }
 
 fn app(cx: Scope) -> Element {
-    let elements = use_state(cx, || Vec::new());
+    let elements = use_ref(cx, || Vec::new());
 
-    let add = {
-        to_owned![elements];
-        move |_| {
-            let mut rng = rand::thread_rng();
-            elements.with_mut(|elements| {
-                elements.push(rng.gen());
-            })
-        }
+    let add = |_| {
+        let mut rng = rand::thread_rng();
+        elements.write().push(rng.gen());
     };
 
-    let remove = {
-        to_owned![elements];
-        move |_| {
-            elements.with_mut(|elements| {
-                elements.pop();
-            })
-        }
+    let remove = |_| {
+        elements.write().pop();
     };
 
-    render!(rect {
-        background: "rgb(225, 200, 150)",
-        elements.get().iter().map(|e: &usize| rsx!(
-            rect {
-                key: "{e}",
-                background: "rgb(150, 200, 225)",
-                width: "100%",
-                label {
-                    "Element {e}"
-                }
-            }
-        ))
+    render!(
         Button {
             onclick: add,
             label {
@@ -56,5 +35,14 @@ fn app(cx: Scope) -> Element {
                 "Remove"
             }
         }
-    })
+        elements.read().iter().map(|e: &usize| rsx!(
+            rect {
+                key: "{e}",
+                background: "rgb(150, 200, 225)",
+                label {
+                    "Element {e}"
+                }
+            }
+        ))
+    )
 }