diff --git a/packages/core/src/diff_stack.rs b/packages/core/src/diff_stack.rs
index 949608a98..2a7f23f35 100644
--- a/packages/core/src/diff_stack.rs
+++ b/packages/core/src/diff_stack.rs
@@ -62,10 +62,6 @@ impl<'bump> DiffStack<'bump> {
         self.scope_stack.pop();
     }
 
-    pub fn pop_scope(&mut self) -> Option<ScopeId> {
-        self.scope_stack.pop()
-    }
-
     pub fn push(&mut self, instruction: DiffInstruction<'bump>) {
         self.instructions.push(instruction)
     }
diff --git a/packages/core/src/events.rs b/packages/core/src/events.rs
index f1b6653e1..8e5152152 100644
--- a/packages/core/src/events.rs
+++ b/packages/core/src/events.rs
@@ -3,16 +3,18 @@
 //!
 //! 3rd party renderers are responsible for converting their native events into these virtual event types. Events might
 //! be heavy or need to interact through FFI, so the events themselves are designed to be lazy.
-use crate::innerlude::{ElementId, ScopeId};
-
-use bumpalo::boxed::Box as BumpBox;
-use std::{any::Any, cell::RefCell, fmt::Debug, ops::Deref, rc::Rc};
-
 use crate::{
-    innerlude::NodeFactory,
-    innerlude::{Attribute, Listener, VNode},
+    innerlude::Listener,
+    innerlude::{ElementId, NodeFactory, ScopeId},
+};
+use bumpalo::boxed::Box as BumpBox;
+use std::{
+    any::Any,
+    cell::{Cell, RefCell},
+    fmt::Debug,
+    ops::Deref,
+    rc::Rc,
 };
-use std::cell::Cell;
 
 #[derive(Debug)]
 pub struct UserEvent {
@@ -832,7 +834,7 @@ pub mod on {
             }
 
             // get the raw code
-            fn raw_code(&self) -> u32 {
+            pub fn raw_code(&self) -> u32 {
                 *self as u32
             }
         }
diff --git a/packages/core/src/lib.rs b/packages/core/src/lib.rs
index 032ae5743..cba274fbe 100644
--- a/packages/core/src/lib.rs
+++ b/packages/core/src/lib.rs
@@ -28,7 +28,6 @@ pub mod scheduler;
 pub mod scope;
 pub mod test_dom;
 pub mod util;
-pub mod vdomdisplay;
 pub mod virtual_dom;
 
 pub(crate) mod innerlude {
diff --git a/packages/core/src/scope.rs b/packages/core/src/scope.rs
index 761e7897f..af69429de 100644
--- a/packages/core/src/scope.rs
+++ b/packages/core/src/scope.rs
@@ -328,3 +328,110 @@ impl Scope {
         }
     }
 }
+
+/// render the scope to a string using the rsx! syntax
+pub(crate) struct ScopeRenderer<'a> {
+    pub skip_components: bool,
+    pub show_fragments: bool,
+    pub _scope: &'a Scope,
+    pub _pre_render: bool,
+    pub _newline: bool,
+    pub _indent: bool,
+    pub _max_depth: usize,
+}
+
+// this is more or less a debug tool, but it'll render the entire tree to the terminal
+impl<'a> ScopeRenderer<'a> {
+    pub fn render(
+        &self,
+        vdom: &VirtualDom,
+        node: &VNode,
+        f: &mut std::fmt::Formatter,
+        il: u16,
+    ) -> std::fmt::Result {
+        const INDENT: &str = "    ";
+        let write_indent = |_f: &mut std::fmt::Formatter, le| {
+            for _ in 0..le {
+                write!(_f, "{}", INDENT).unwrap();
+            }
+        };
+
+        match &node {
+            VNode::Text(text) => {
+                write_indent(f, il);
+                write!(f, "\"{}\"\n", text.text)?
+            }
+            VNode::Anchor(anchor) => {
+                write_indent(f, il);
+                write!(f, "Anchor {{}}\n")?;
+            }
+            VNode::Element(el) => {
+                write_indent(f, il);
+                write!(f, "{} {{\n", el.tag_name)?;
+                // write!(f, "element: {}", el.tag_name)?;
+                let mut attr_iter = el.attributes.iter().peekable();
+
+                while let Some(attr) = attr_iter.next() {
+                    match attr.namespace {
+                        None => {
+                            //
+                            write_indent(f, il + 1);
+                            write!(f, "{}: \"{}\"\n", attr.name, attr.value)?
+                        }
+
+                        Some(ns) => {
+                            // write the opening tag
+                            write_indent(f, il + 1);
+                            write!(f, " {}:\"", ns)?;
+                            let mut cur_ns_el = attr;
+                            'ns_parse: loop {
+                                write!(f, "{}:{};", cur_ns_el.name, cur_ns_el.value)?;
+                                match attr_iter.peek() {
+                                    Some(next_attr) if next_attr.namespace == Some(ns) => {
+                                        cur_ns_el = attr_iter.next().unwrap();
+                                    }
+                                    _ => break 'ns_parse,
+                                }
+                            }
+                            // write the closing tag
+                            write!(f, "\"")?;
+                        }
+                    }
+                }
+
+                for child in el.children {
+                    self.render(vdom, child, f, il + 1)?;
+                }
+                write_indent(f, il);
+
+                write!(f, "}}\n")?;
+            }
+            VNode::Fragment(frag) => {
+                if self.show_fragments {
+                    write_indent(f, il);
+                    write!(f, "Fragment {{\n")?;
+                    for child in frag.children {
+                        self.render(vdom, child, f, il + 1)?;
+                    }
+                    write_indent(f, il);
+                    write!(f, "}}\n")?;
+                } else {
+                    for child in frag.children {
+                        self.render(vdom, child, f, il)?;
+                    }
+                }
+            }
+            VNode::Component(vcomp) => {
+                let idx = vcomp.associated_scope.get().unwrap();
+                if !self.skip_components {
+                    let new_node = vdom.get_scope(idx).unwrap().root_node();
+                    self.render(vdom, new_node, f, il)?;
+                }
+            }
+            VNode::Suspended { .. } => {
+                // we can't do anything with suspended nodes
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/packages/core/src/test_dom.rs b/packages/core/src/test_dom.rs
index 55cdc8974..6e89e817f 100644
--- a/packages/core/src/test_dom.rs
+++ b/packages/core/src/test_dom.rs
@@ -12,7 +12,7 @@ pub struct TestDom {
 impl TestDom {
     pub fn new() -> TestDom {
         let bump = Bump::new();
-        let mut scheduler = Scheduler::new();
+        let scheduler = Scheduler::new();
         TestDom { bump, scheduler }
     }
 
diff --git a/packages/core/src/vdomdisplay.rs b/packages/core/src/vdomdisplay.rs
deleted file mode 100644
index 326ec5697..000000000
--- a/packages/core/src/vdomdisplay.rs
+++ /dev/null
@@ -1,107 +0,0 @@
-use crate::innerlude::*;
-
-pub(crate) struct ScopeRenderer<'a> {
-    pub skip_components: bool,
-    pub show_fragments: bool,
-    pub _scope: &'a Scope,
-    pub _pre_render: bool,
-    pub _newline: bool,
-    pub _indent: bool,
-    pub _max_depth: usize,
-}
-
-// this is more or less a debug tool, but it'll render the entire tree to the terminal
-impl<'a> ScopeRenderer<'a> {
-    pub fn render(
-        &self,
-        vdom: &VirtualDom,
-        node: &VNode,
-        f: &mut std::fmt::Formatter,
-        il: u16,
-    ) -> std::fmt::Result {
-        const INDENT: &str = "    ";
-        let write_indent = |_f: &mut std::fmt::Formatter, le| {
-            for _ in 0..le {
-                write!(_f, "{}", INDENT).unwrap();
-            }
-        };
-
-        match &node {
-            VNode::Text(text) => {
-                write_indent(f, il);
-                write!(f, "\"{}\"\n", text.text)?
-            }
-            VNode::Anchor(anchor) => {
-                write_indent(f, il);
-                write!(f, "Anchor {{}}\n")?;
-            }
-            VNode::Element(el) => {
-                write_indent(f, il);
-                write!(f, "{} {{\n", el.tag_name)?;
-                // write!(f, "element: {}", el.tag_name)?;
-                let mut attr_iter = el.attributes.iter().peekable();
-
-                while let Some(attr) = attr_iter.next() {
-                    match attr.namespace {
-                        None => {
-                            //
-                            write_indent(f, il + 1);
-                            write!(f, "{}: \"{}\"\n", attr.name, attr.value)?
-                        }
-
-                        Some(ns) => {
-                            // write the opening tag
-                            write_indent(f, il + 1);
-                            write!(f, " {}:\"", ns)?;
-                            let mut cur_ns_el = attr;
-                            'ns_parse: loop {
-                                write!(f, "{}:{};", cur_ns_el.name, cur_ns_el.value)?;
-                                match attr_iter.peek() {
-                                    Some(next_attr) if next_attr.namespace == Some(ns) => {
-                                        cur_ns_el = attr_iter.next().unwrap();
-                                    }
-                                    _ => break 'ns_parse,
-                                }
-                            }
-                            // write the closing tag
-                            write!(f, "\"")?;
-                        }
-                    }
-                }
-
-                for child in el.children {
-                    self.render(vdom, child, f, il + 1)?;
-                }
-                write_indent(f, il);
-
-                write!(f, "}}\n")?;
-            }
-            VNode::Fragment(frag) => {
-                if self.show_fragments {
-                    write_indent(f, il);
-                    write!(f, "Fragment {{\n")?;
-                    for child in frag.children {
-                        self.render(vdom, child, f, il + 1)?;
-                    }
-                    write_indent(f, il);
-                    write!(f, "}}\n")?;
-                } else {
-                    for child in frag.children {
-                        self.render(vdom, child, f, il)?;
-                    }
-                }
-            }
-            VNode::Component(vcomp) => {
-                let idx = vcomp.associated_scope.get().unwrap();
-                if !self.skip_components {
-                    let new_node = vdom.get_scope(idx).unwrap().root_node();
-                    self.render(vdom, new_node, f, il)?;
-                }
-            }
-            VNode::Suspended { .. } => {
-                // we can't do anything with suspended nodes
-            }
-        }
-        Ok(())
-    }
-}
diff --git a/packages/core/src/virtual_dom.rs b/packages/core/src/virtual_dom.rs
index 329092ff5..6333c0817 100644
--- a/packages/core/src/virtual_dom.rs
+++ b/packages/core/src/virtual_dom.rs
@@ -362,8 +362,6 @@ impl std::fmt::Display for VirtualDom {
         let base = self.base_scope();
         let root = base.root_node();
 
-        use crate::vdomdisplay::ScopeRenderer;
-
         let renderer = ScopeRenderer {
             show_fragments: false,
             skip_components: false,