diff --git a/crates/gosub_net/src/http/fetcher.rs b/crates/gosub_net/src/http/fetcher.rs
index 305a72356..d86064725 100644
--- a/crates/gosub_net/src/http/fetcher.rs
+++ b/crates/gosub_net/src/http/fetcher.rs
@@ -35,6 +35,10 @@ impl Fetcher {
         }
     }
 
+    pub fn base(&self) -> &Url {
+        &self.base_url
+    }
+
     pub async fn get_url(&self, url: &Url) -> Result<Response> {
         let scheme = url.scheme();
 
diff --git a/crates/gosub_render_backend/src/lib.rs b/crates/gosub_render_backend/src/lib.rs
index 87b435a3f..b137a354e 100644
--- a/crates/gosub_render_backend/src/lib.rs
+++ b/crates/gosub_render_backend/src/lib.rs
@@ -5,6 +5,8 @@ use crate::layout::TextLayout;
 use crate::svg::SvgRenderer;
 pub use geo::*;
 use gosub_shared::async_executor::WasmNotSendSync;
+use gosub_shared::traits::css3::CssSystem;
+use gosub_shared::traits::render_tree::RenderTree;
 use gosub_shared::types::Result;
 use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
 use smallvec::SmallVec;
@@ -17,10 +19,14 @@ pub trait WindowHandle: HasDisplayHandle + HasWindowHandle + Send + Sync + Clone
 
 impl<T> WindowHandle for T where T: HasDisplayHandle + HasWindowHandle + Send + Sync + Clone {}
 
-pub trait WindowedEventLoop<B: RenderBackend>: WasmNotSendSync + Clone + 'static {
+pub trait WindowedEventLoop<B: RenderBackend, RT: RenderTree<C>, C: CssSystem>:
+    WasmNotSendSync + Clone + 'static
+{
     fn redraw(&mut self);
 
     fn add_img_cache(&mut self, url: String, buf: ImageBuffer<B>, size: Option<SizeU32>);
+
+    fn reload_from(&mut self, rt: RT);
 }
 
 pub trait RenderBackend: Sized + Debug + 'static {
diff --git a/crates/gosub_renderer/src/draw.rs b/crates/gosub_renderer/src/draw.rs
index 7afe2a0d1..b95473c1d 100644
--- a/crates/gosub_renderer/src/draw.rs
+++ b/crates/gosub_renderer/src/draw.rs
@@ -1,7 +1,7 @@
 use crate::debug::scale::px_scale;
 use crate::draw::img::request_img;
 use crate::draw::img_cache::ImageCache;
-use crate::render_tree::{load_html_rendertree, TreeDrawer};
+use crate::render_tree::{load_html_rendertree, load_html_rendertree_fetcher, TreeDrawer};
 use anyhow::anyhow;
 use gosub_net::http::fetcher::Fetcher;
 use gosub_render_backend::geo::{Size, SizeU32, FP};
@@ -18,9 +18,11 @@ use gosub_shared::node::NodeId;
 use gosub_shared::traits::css3::{CssProperty, CssPropertyMap, CssSystem};
 use gosub_shared::traits::document::Document;
 use gosub_shared::traits::html5::Html5Parser;
+use gosub_shared::traits::render_tree;
 use gosub_shared::types::Result;
-use log::warn;
+use log::{error, info, warn};
 use std::future::Future;
+use std::marker::PhantomData;
 use std::sync::mpsc::Sender;
 use std::sync::{Arc, Mutex};
 use url::Url;
@@ -28,8 +30,14 @@ use url::Url;
 mod img;
 pub mod img_cache;
 
-pub trait SceneDrawer<B: RenderBackend, L: Layouter, LT: LayoutTree<L>, D: Document<C>, C: CssSystem>:
-    WasmNotSend + 'static
+pub trait SceneDrawer<
+    B: RenderBackend,
+    L: Layouter,
+    LT: LayoutTree<L>,
+    D: Document<C>,
+    C: CssSystem,
+    RT: render_tree::RenderTree<C>,
+>: WasmNotSend + 'static
 {
     type ImgCache: ImgCache<B>;
 
@@ -38,7 +46,7 @@ pub trait SceneDrawer<B: RenderBackend, L: Layouter, LT: LayoutTree<L>, D: Docum
         backend: &mut B,
         data: &mut B::WindowData<'_>,
         size: SizeU32,
-        el: &impl WindowedEventLoop<B>,
+        el: &impl WindowedEventLoop<B, RT, C>,
     ) -> bool;
     fn mouse_move(&mut self, backend: &mut B, x: FP, y: FP) -> bool;
 
@@ -63,6 +71,10 @@ pub trait SceneDrawer<B: RenderBackend, L: Layouter, LT: LayoutTree<L>, D: Docum
     fn make_dirty(&mut self);
 
     fn delete_scene(&mut self);
+
+    fn reload<P: Html5Parser<C, Document = D>>(&mut self, el: impl WindowedEventLoop<B, RT, C>);
+
+    fn reload_from(&mut self, tree: RT);
 }
 
 const DEBUG_CONTENT_COLOR: (u8, u8, u8) = (0, 192, 255); //rgb(0, 192, 255)
@@ -72,8 +84,8 @@ const DEBUG_BORDER_COLOR: (u8, u8, u8) = (255, 72, 72); //rgb(255, 72, 72)
 
 type Point = gosub_shared::types::Point<FP>;
 
-impl<B: RenderBackend, L: Layouter, D: Document<C>, C: CssSystem> SceneDrawer<B, L, RenderTree<L, C>, D, C>
-    for TreeDrawer<B, L, D, C>
+impl<B: RenderBackend, L: Layouter, D: Document<C>, C: CssSystem>
+    SceneDrawer<B, L, RenderTree<L, C>, D, C, RenderTree<L, C>> for TreeDrawer<B, L, D, C>
 where
     <<B as RenderBackend>::Text as Text>::Font: From<<<L as Layouter>::TextLayout as TextLayout>::Font>,
 {
@@ -84,7 +96,7 @@ where
         backend: &mut B,
         data: &mut B::WindowData<'_>,
         size: SizeU32,
-        el: &impl WindowedEventLoop<B>,
+        el: &impl WindowedEventLoop<B, RenderTree<L, C>, C>,
     ) -> bool {
         if !self.dirty && self.size == Some(size) {
             return false;
@@ -113,6 +125,7 @@ where
                 drawer: self,
                 svg: Arc::new(Mutex::new(B::SVGRenderer::new())),
                 el,
+                _marker: PhantomData,
             };
 
             drawer.render(size);
@@ -265,17 +278,63 @@ where
         self.tree_scene = None;
         self.debugger_scene = None;
     }
+
+    fn reload<P: Html5Parser<C, Document = D>>(&mut self, mut el: impl WindowedEventLoop<B, RenderTree<L, C>, C>) {
+        let fetcher = self.fetcher.clone();
+
+        gosub_shared::async_executor::spawn(async move {
+            info!("Reloading tab");
+
+            let rt = match load_html_rendertree_fetcher::<L, P, C>(fetcher.base().clone(), &fetcher).await {
+                Ok(rt) => rt,
+                Err(e) => {
+                    error!("Failed to reload tab: {e}");
+                    return;
+                }
+            };
+
+            el.reload_from(rt);
+        })
+    }
+
+    fn reload_from(&mut self, tree: RenderTree<L, C>) {
+        self.tree = tree;
+        self.size = None;
+        self.position = PositionTree::default();
+        self.last_hover = None;
+        self.debugger_scene = None;
+        self.dirty = false;
+        self.tree_scene = None;
+        self.selected_element = None;
+        self.scene_transform = None;
+    }
 }
 
-struct Drawer<'s, 't, B: RenderBackend, L: Layouter, D: Document<C>, C: CssSystem, EL: WindowedEventLoop<B>> {
+struct Drawer<
+    's,
+    't,
+    B: RenderBackend,
+    L: Layouter,
+    D: Document<C>,
+    C: CssSystem,
+    EL: WindowedEventLoop<B, RT, C>,
+    RT: render_tree::RenderTree<C>,
+> {
     scene: &'s mut B::Scene,
     drawer: &'t mut TreeDrawer<B, L, D, C>,
     svg: Arc<Mutex<B::SVGRenderer>>,
     el: &'t EL,
+    _marker: PhantomData<fn(RT)>,
 }
 
-impl<B: RenderBackend, L: Layouter, D: Document<C>, C: CssSystem, EL: WindowedEventLoop<B>>
-    Drawer<'_, '_, B, L, D, C, EL>
+impl<
+        B: RenderBackend,
+        L: Layouter,
+        D: Document<C>,
+        C: CssSystem,
+        EL: WindowedEventLoop<B, RT, C>,
+        RT: render_tree::RenderTree<C>,
+    > Drawer<'_, '_, B, L, D, C, EL, RT>
 where
     <<B as RenderBackend>::Text as Text>::Font: From<<<L as Layouter>::TextLayout as TextLayout>::Font>,
 {
@@ -316,7 +375,7 @@ where
         pos.x += p.x as FP;
         pos.y += p.y as FP;
 
-        let (border_radius, new_size) = render_bg::<B, L, C>(
+        let (border_radius, new_size) = render_bg::<B, L, C, RT>(
             node,
             self.scene,
             pos,
@@ -336,7 +395,7 @@ where
 
                 let size = node.layout.size_or().map(|x| x.u32());
 
-                let img = request_img::<B>(
+                let img = request_img::<B, RT, C>(
                     self.drawer.fetcher.clone(),
                     self.svg.clone(),
                     url,
@@ -570,14 +629,14 @@ pub fn print_tree<B: RenderBackend, L: Layouter>(
 }
 */
 
-fn render_bg<B: RenderBackend, L: Layouter, C: CssSystem>(
+fn render_bg<B: RenderBackend, L: Layouter, C: CssSystem, RT: render_tree::RenderTree<C>>(
     node: &RenderTreeNode<L, C>,
     scene: &mut B::Scene,
     pos: &Point,
     svg: Arc<Mutex<B::SVGRenderer>>,
     fetcher: Arc<Fetcher>,
     img_cache: &mut ImageCache<B>,
-    el: &impl WindowedEventLoop<B>,
+    el: &impl WindowedEventLoop<B, RT, C>,
 ) -> ((FP, FP, FP, FP), Option<SizeU32>) {
     let bg_color = node
         .properties
@@ -660,7 +719,7 @@ fn render_bg<B: RenderBackend, L: Layouter, C: CssSystem>(
     if let Some(url) = background_image {
         let size = node.layout.size_or().map(|x| x.u32());
 
-        let img = match request_img::<B>(fetcher.clone(), svg.clone(), url, size, img_cache, el) {
+        let img = match request_img::<B, RT, C>(fetcher.clone(), svg.clone(), url, size, img_cache, el) {
             Ok(img) => img,
             Err(e) => {
                 eprintln!("Error loading image: {:?}", e);
diff --git a/crates/gosub_renderer/src/draw/img.rs b/crates/gosub_renderer/src/draw/img.rs
index 46a73a348..db74f059a 100644
--- a/crates/gosub_renderer/src/draw/img.rs
+++ b/crates/gosub_renderer/src/draw/img.rs
@@ -10,15 +10,17 @@ use gosub_render_backend::svg::SvgRenderer;
 use gosub_render_backend::{
     Image as _, ImageBuffer, ImageCacheEntry, ImgCache, RenderBackend, SizeU32, WindowedEventLoop,
 };
+use gosub_shared::traits::css3::CssSystem;
+use gosub_shared::traits::render_tree::RenderTree;
 use gosub_shared::types::Result;
 
-pub fn request_img<B: RenderBackend>(
+pub fn request_img<B: RenderBackend, RT: RenderTree<C>, C: CssSystem>(
     fetcher: Arc<Fetcher>,
     svg_renderer: Arc<Mutex<B::SVGRenderer>>,
     url: &str,
     size: Option<SizeU32>,
     img_cache: &mut ImageCache<B>,
-    el: &impl WindowedEventLoop<B>,
+    el: &impl WindowedEventLoop<B, RT, C>,
 ) -> Result<ImageBuffer<B>> {
     let img = img_cache.get(url);
 
diff --git a/crates/gosub_renderer/src/render_tree.rs b/crates/gosub_renderer/src/render_tree.rs
index b37e211dc..3134f1fcf 100644
--- a/crates/gosub_renderer/src/render_tree.rs
+++ b/crates/gosub_renderer/src/render_tree.rs
@@ -70,6 +70,16 @@ pub(crate) async fn load_html_rendertree<L: Layouter, P: Html5Parser<C>, C: CssS
     url: Url,
 ) -> gosub_shared::types::Result<(RenderTree<L, C>, Fetcher)> {
     let fetcher = Fetcher::new(url.clone());
+
+    let rt = load_html_rendertree_fetcher::<L, P, C>(url, &fetcher).await?;
+
+    Ok((rt, fetcher))
+}
+
+pub(crate) async fn load_html_rendertree_fetcher<L: Layouter, P: Html5Parser<C>, C: CssSystem>(
+    url: Url,
+    fetcher: &Fetcher,
+) -> gosub_shared::types::Result<RenderTree<L, C>> {
     let html = if url.scheme() == "http" || url.scheme() == "https" {
         // Fetch the html from the url
         let response = fetcher.get(url.as_ref()).await?;
@@ -101,5 +111,5 @@ pub(crate) async fn load_html_rendertree<L: Layouter, P: Html5Parser<C>, C: CssS
 
     drop(doc);
 
-    Ok((generate_render_tree(DocumentHandle::clone(&doc_handle))?, fetcher))
+    generate_render_tree(DocumentHandle::clone(&doc_handle))
 }
diff --git a/crates/gosub_shared/src/traits/render_tree.rs b/crates/gosub_shared/src/traits/render_tree.rs
index e440b0123..1fb6b97fe 100644
--- a/crates/gosub_shared/src/traits/render_tree.rs
+++ b/crates/gosub_shared/src/traits/render_tree.rs
@@ -1,6 +1,6 @@
 use crate::traits::css3::CssSystem;
 
-pub trait RenderTree<C: CssSystem> {
+pub trait RenderTree<C: CssSystem>: Send + 'static {
     type NodeId: Copy;
 
     type Node: RenderTreeNode<C>;
diff --git a/crates/gosub_useragent/src/application.rs b/crates/gosub_useragent/src/application.rs
index d80d92e2c..830221592 100644
--- a/crates/gosub_useragent/src/application.rs
+++ b/crates/gosub_useragent/src/application.rs
@@ -16,6 +16,7 @@ use gosub_renderer::draw::SceneDrawer;
 use gosub_shared::traits::css3::CssSystem;
 use gosub_shared::traits::document::Document;
 use gosub_shared::traits::html5::Html5Parser;
+use gosub_shared::traits::render_tree::RenderTree;
 use gosub_shared::types::Result;
 
 use crate::tabs::Tab;
@@ -39,38 +40,41 @@ impl WindowOptions {
     }
 }
 
+#[allow(clippy::type_complexity)]
 pub struct Application<
     'a,
-    D: SceneDrawer<B, L, LT, Doc, C>,
+    D: SceneDrawer<B, L, LT, Doc, C, RT>,
     B: RenderBackend,
     L: Layouter,
     LT: LayoutTree<L>,
     Doc: Document<C>,
     C: CssSystem,
     P: Html5Parser<C, Document = Doc>,
+    RT: RenderTree<C>,
 > {
     open_windows: Vec<(Vec<Url>, WindowOptions)>, // Vec of Windows, each with a Vec of URLs, representing tabs
-    windows: HashMap<WindowId, Window<'a, D, B, L, LT, Doc, C>>,
+    windows: HashMap<WindowId, Window<'a, D, B, L, LT, Doc, C, RT>>,
     backend: B,
     layouter: L,
     #[allow(clippy::type_complexity)]
-    proxy: Option<EventLoopProxy<CustomEventInternal<D, B, L, LT, Doc, C>>>,
+    proxy: Option<EventLoopProxy<CustomEventInternal<D, B, L, LT, Doc, C, RT>>>,
     #[allow(clippy::type_complexity)]
-    event_loop: Option<EventLoop<CustomEventInternal<D, B, L, LT, Doc, C>>>,
+    event_loop: Option<EventLoop<CustomEventInternal<D, B, L, LT, Doc, C, RT>>>,
     debug: bool,
     _marker: std::marker::PhantomData<&'a P>,
 }
 
 impl<
         'a,
-        D: SceneDrawer<B, L, LT, Doc, C>,
+        D: SceneDrawer<B, L, LT, Doc, C, RT>,
         B: RenderBackend,
         L: Layouter,
         LT: LayoutTree<L>,
         Doc: Document<C>,
         C: CssSystem,
         P: Html5Parser<C, Document = Doc>,
-    > ApplicationHandler<CustomEventInternal<D, B, L, LT, Doc, C>> for Application<'a, D, B, L, LT, Doc, C, P>
+        RT: RenderTree<C>,
+    > ApplicationHandler<CustomEventInternal<D, B, L, LT, Doc, C, RT>> for Application<'a, D, B, L, LT, Doc, C, P, RT>
 {
     fn resumed(&mut self, _event_loop: &ActiveEventLoop) {
         info!("Resumed");
@@ -81,7 +85,7 @@ impl<
         }
     }
 
-    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: CustomEventInternal<D, B, L, LT, Doc, C>) {
+    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: CustomEventInternal<D, B, L, LT, Doc, C, RT>) {
         match event {
             CustomEventInternal::OpenWindow(url, id) => {
                 info!("Opening window with URL: {url}");
@@ -243,6 +247,15 @@ impl<
 
                         tab.data.delete_scene();
 
+                        window.request_redraw();
+                    }
+                }
+            }
+            CustomEventInternal::ReloadFrom(rt, id) => {
+                if let Some(window) = self.windows.get_mut(&id) {
+                    if let Some(tab) = window.tabs.get_current_tab() {
+                        tab.reload_from(rt);
+
                         window.request_redraw();
                     }
                 }
@@ -252,7 +265,7 @@ impl<
 
     fn window_event(&mut self, event_loop: &ActiveEventLoop, window_id: WindowId, event: WindowEvent) {
         if let Some(window) = self.windows.get_mut(&window_id) {
-            if let Err(e) = window.event(event_loop, &mut self.backend, event) {
+            if let Err(e) = window.event::<P>(event_loop, &mut self.backend, event) {
                 eprintln!("Error handling window event: {e:?}");
             };
         }
@@ -267,14 +280,15 @@ impl<
 
 impl<
         'a,
-        D: SceneDrawer<B, L, LT, Doc, C>,
+        D: SceneDrawer<B, L, LT, Doc, C, RT>,
         B: RenderBackend,
         L: Layouter,
         LT: LayoutTree<L>,
         Doc: Document<C>,
         C: CssSystem,
         P: Html5Parser<C, Document = Doc>,
-    > Application<'a, D, B, L, LT, Doc, C, P>
+        RT: RenderTree<C>,
+    > Application<'a, D, B, L, LT, Doc, C, P, RT>
 {
     pub fn new(backend: B, layouter: L, debug: bool) -> Self {
         Self {
@@ -297,7 +311,7 @@ impl<
         self.open_windows.append(&mut windows);
     }
 
-    pub fn add_window(&mut self, window: Window<'a, D, B, L, LT, Doc, C>) {
+    pub fn add_window(&mut self, window: Window<'a, D, B, L, LT, Doc, C, RT>) {
         self.windows.insert(window.window.id(), window);
     }
 
@@ -336,7 +350,7 @@ impl<
     }
 
     #[allow(clippy::type_complexity)]
-    pub fn proxy(&mut self) -> Result<EventLoopProxy<CustomEventInternal<D, B, L, LT, Doc, C>>> {
+    pub fn proxy(&mut self) -> Result<EventLoopProxy<CustomEventInternal<D, B, L, LT, Doc, C, RT>>> {
         if self.proxy.is_none() {
             self.initialize()?;
         }
@@ -362,16 +376,17 @@ pub enum CustomEvent {
     Unselect,
 }
 pub enum CustomEventInternal<
-    D: SceneDrawer<B, L, LT, Doc, C>,
+    D: SceneDrawer<B, L, LT, Doc, C, RT>,
     B: RenderBackend,
     L: Layouter,
     LT: LayoutTree<L>,
     Doc: Document<C>,
     C: CssSystem,
+    RT: RenderTree<C>,
 > {
     OpenWindow(Url, WindowOptions),
     OpenTab(Url, WindowId),
-    AddTab(Tab<D, B, L, LT, Doc, C>, WindowId),
+    AddTab(Tab<D, B, L, LT, Doc, C, RT>, WindowId),
     CloseWindow(WindowId),
     OpenInitial,
     Select(u64),
@@ -379,16 +394,18 @@ pub enum CustomEventInternal<
     Unselect,
     Redraw(WindowId),
     AddImg(String, ImageBuffer<B>, Option<SizeU32>, WindowId),
+    ReloadFrom(RT, WindowId),
 }
 
 impl<
-        D: SceneDrawer<B, L, LT, Doc, C>,
+        D: SceneDrawer<B, L, LT, Doc, C, RT>,
         B: RenderBackend,
         L: Layouter,
         LT: LayoutTree<L>,
         Doc: Document<C>,
         C: CssSystem,
-    > Debug for CustomEventInternal<D, B, L, LT, Doc, C>
+        RT: RenderTree<C>,
+    > Debug for CustomEventInternal<D, B, L, LT, Doc, C, RT>
 {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -402,6 +419,7 @@ impl<
             Self::Unselect => f.write_str("Unselect"),
             Self::Redraw(_) => f.write_str("Redraw"),
             Self::AddImg(..) => f.write_str("AddImg"),
+            Self::ReloadFrom(..) => f.write_str("ReloadFrom"),
         }
     }
 }
diff --git a/crates/gosub_useragent/src/event_loop.rs b/crates/gosub_useragent/src/event_loop.rs
index aee4f6481..580f3b3ca 100644
--- a/crates/gosub_useragent/src/event_loop.rs
+++ b/crates/gosub_useragent/src/event_loop.rs
@@ -7,21 +7,29 @@ use gosub_render_backend::{Point, RenderBackend, SizeU32, FP};
 use gosub_renderer::draw::SceneDrawer;
 use gosub_shared::traits::css3::CssSystem;
 use gosub_shared::traits::document::Document;
+use gosub_shared::traits::html5::Html5Parser;
+use gosub_shared::traits::render_tree::RenderTree;
 use gosub_shared::types::Result;
 
 use crate::window::{Window, WindowState};
 
 impl<
         'a,
-        D: SceneDrawer<B, L, LT, Doc, C>,
+        D: SceneDrawer<B, L, LT, Doc, C, RT>,
         B: RenderBackend,
         L: Layouter,
         LT: LayoutTree<L>,
         Doc: Document<C>,
         C: CssSystem,
-    > Window<'a, D, B, L, LT, Doc, C>
+        RT: RenderTree<C>,
+    > Window<'a, D, B, L, LT, Doc, C, RT>
 {
-    pub fn event(&mut self, el: &ActiveEventLoop, backend: &mut B, event: WindowEvent) -> Result<()> {
+    pub fn event<P: Html5Parser<C, Document = Doc>>(
+        &mut self,
+        el: &ActiveEventLoop,
+        backend: &mut B,
+        event: WindowEvent,
+    ) -> Result<()> {
         let WindowState::Active {
             surface: active_window_data,
         } = &mut self.state
@@ -107,6 +115,9 @@ impl<
                             tab.data.clear_buffers();
                             self.window.request_redraw();
                         }
+                        KeyCode::F5 => {
+                            tab.reload::<P>(self.el.clone());
+                        }
                         _ => {}
                     }
                 }
diff --git a/crates/gosub_useragent/src/tabs.rs b/crates/gosub_useragent/src/tabs.rs
index f95e80e4e..2423d3a8a 100644
--- a/crates/gosub_useragent/src/tabs.rs
+++ b/crates/gosub_useragent/src/tabs.rs
@@ -1,9 +1,10 @@
 use gosub_render_backend::layout::{LayoutTree, Layouter};
-use gosub_render_backend::{NodeDesc, RenderBackend};
+use gosub_render_backend::{NodeDesc, RenderBackend, WindowedEventLoop};
 use gosub_renderer::draw::SceneDrawer;
 use gosub_shared::traits::css3::CssSystem;
 use gosub_shared::traits::document::Document;
 use gosub_shared::traits::html5::Html5Parser;
+use gosub_shared::traits::render_tree::RenderTree;
 use gosub_shared::types::Result;
 use log::info;
 use slotmap::{DefaultKey, SlotMap};
@@ -11,26 +12,29 @@ use std::sync::mpsc::Sender;
 use url::Url;
 
 pub struct Tabs<
-    D: SceneDrawer<B, L, LT, Doc, C>,
+    D: SceneDrawer<B, L, LT, Doc, C, RT>,
     B: RenderBackend,
     L: Layouter,
     LT: LayoutTree<L>,
     Doc: Document<C>,
     C: CssSystem,
+    RT: RenderTree<C>,
 > {
-    pub tabs: SlotMap<DefaultKey, Tab<D, B, L, LT, Doc, C>>,
+    #[allow(clippy::type_complexity)]
+    pub tabs: SlotMap<DefaultKey, Tab<D, B, L, LT, Doc, C, RT>>,
     pub active: TabID,
     _marker: std::marker::PhantomData<(B, L, LT)>,
 }
 
 impl<
-        D: SceneDrawer<B, L, LT, Doc, C>,
+        D: SceneDrawer<B, L, LT, Doc, C, RT>,
         L: Layouter,
         LT: LayoutTree<L>,
         B: RenderBackend,
         Doc: Document<C>,
         C: CssSystem,
-    > Default for Tabs<D, B, L, LT, Doc, C>
+        RT: RenderTree<C>,
+    > Default for Tabs<D, B, L, LT, Doc, C, RT>
 {
     fn default() -> Self {
         Self {
@@ -42,15 +46,16 @@ impl<
 }
 
 impl<
-        D: SceneDrawer<B, L, LT, Doc, C>,
+        D: SceneDrawer<B, L, LT, Doc, C, RT>,
         L: Layouter,
         LT: LayoutTree<L>,
         B: RenderBackend,
         Doc: Document<C>,
         C: CssSystem,
-    > Tabs<D, B, L, LT, Doc, C>
+        RT: RenderTree<C>,
+    > Tabs<D, B, L, LT, Doc, C, RT>
 {
-    pub fn new(initial: Tab<D, B, L, LT, Doc, C>) -> Self {
+    pub fn new(initial: Tab<D, B, L, LT, Doc, C, RT>) -> Self {
         let mut tabs = SlotMap::new();
         let active = TabID(tabs.insert(initial));
 
@@ -61,7 +66,7 @@ impl<
         }
     }
 
-    pub fn add_tab(&mut self, tab: Tab<D, B, L, LT, Doc, C>) -> TabID {
+    pub fn add_tab(&mut self, tab: Tab<D, B, L, LT, Doc, C, RT>) -> TabID {
         TabID(self.tabs.insert(tab))
     }
 
@@ -73,7 +78,7 @@ impl<
         self.active = id;
     }
 
-    pub fn get_current_tab(&mut self) -> Option<&mut Tab<D, B, L, LT, Doc, C>> {
+    pub fn get_current_tab(&mut self) -> Option<&mut Tab<D, B, L, LT, Doc, C, RT>> {
         self.tabs.get_mut(self.active.0)
     }
 
@@ -108,28 +113,30 @@ impl<
 
 #[derive(Debug)]
 pub struct Tab<
-    D: SceneDrawer<B, L, LT, Doc, C>,
+    D: SceneDrawer<B, L, LT, Doc, C, RT>,
     B: RenderBackend,
     L: Layouter,
     LT: LayoutTree<L>,
     Doc: Document<C>,
     C: CssSystem,
+    RT: RenderTree<C>,
 > {
     pub title: String,
     pub url: Url,
     pub data: D,
     #[allow(clippy::type_complexity)]
-    _marker: std::marker::PhantomData<fn(B, L, LT, Doc, C)>,
+    _marker: std::marker::PhantomData<fn(B, L, LT, Doc, C, RT)>,
 }
 
 impl<
-        D: SceneDrawer<B, L, LT, Doc, C>,
+        D: SceneDrawer<B, L, LT, Doc, C, RT>,
         B: RenderBackend,
         L: Layouter,
         LT: LayoutTree<L>,
         Doc: Document<C>,
         C: CssSystem,
-    > Tab<D, B, L, LT, Doc, C>
+        RT: RenderTree<C>,
+    > Tab<D, B, L, LT, Doc, C, RT>
 {
     pub fn new(title: String, url: Url, data: D) -> Self {
         Self {
@@ -152,6 +159,14 @@ impl<
             _marker: std::marker::PhantomData,
         })
     }
+
+    pub fn reload<P: Html5Parser<C, Document = Doc>>(&mut self, el: impl WindowedEventLoop<B, RT, C>) {
+        self.data.reload::<P>(el);
+    }
+
+    pub fn reload_from(&mut self, rt: RT) {
+        self.data.reload_from(rt)
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default)]
diff --git a/crates/gosub_useragent/src/window.rs b/crates/gosub_useragent/src/window.rs
index 1c6f5daf4..846b48f80 100644
--- a/crates/gosub_useragent/src/window.rs
+++ b/crates/gosub_useragent/src/window.rs
@@ -18,6 +18,7 @@ use gosub_renderer::draw::SceneDrawer;
 use gosub_shared::traits::css3::CssSystem;
 use gosub_shared::traits::document::Document;
 use gosub_shared::traits::html5::Html5Parser;
+use gosub_shared::traits::render_tree::RenderTree;
 use gosub_shared::types::Result;
 
 use crate::application::{CustomEventInternal, WindowOptions};
@@ -52,35 +53,37 @@ static ICON: LazyCell<Icon> = LazyCell::new(|| {
 
 pub struct Window<
     'a,
-    D: SceneDrawer<B, L, LT, Doc, C>,
+    D: SceneDrawer<B, L, LT, Doc, C, RT>,
     B: RenderBackend,
     L: Layouter,
     LT: LayoutTree<L>,
     Doc: Document<C>,
     C: CssSystem,
+    RT: RenderTree<C>,
 > {
     pub(crate) state: WindowState<'a, B>,
     pub(crate) window: Arc<WinitWindow>,
     pub(crate) renderer_data: B::WindowData<'a>,
-    pub(crate) tabs: Tabs<D, B, L, LT, Doc, C>,
-    pub(crate) el: WindowEventLoop<D, B, L, LT, Doc, C>,
+    pub(crate) tabs: Tabs<D, B, L, LT, Doc, C, RT>,
+    pub(crate) el: WindowEventLoop<D, B, L, LT, Doc, C, RT>,
 }
 
 impl<
         'a,
-        D: SceneDrawer<B, L, LT, Doc, C>,
+        D: SceneDrawer<B, L, LT, Doc, C, RT>,
         B: RenderBackend,
         L: Layouter,
         LT: LayoutTree<L>,
         Doc: Document<C>,
         C: CssSystem,
-    > Window<'a, D, B, L, LT, Doc, C>
+        RT: RenderTree<C>,
+    > Window<'a, D, B, L, LT, Doc, C, RT>
 {
     pub fn new<P: Html5Parser<C, Document = Doc>>(
         event_loop: &ActiveEventLoop,
         backend: &mut B,
         opts: WindowOptions,
-        el: EventLoopProxy<CustomEventInternal<D, B, L, LT, Doc, C>>,
+        el: EventLoopProxy<CustomEventInternal<D, B, L, LT, Doc, C, RT>>,
     ) -> Result<Self> {
         let window = create_window(event_loop)?;
 
@@ -137,7 +140,7 @@ impl<
         Ok(())
     }
 
-    pub fn add_tab(&mut self, tab: Tab<D, B, L, LT, Doc, C>) {
+    pub fn add_tab(&mut self, tab: Tab<D, B, L, LT, Doc, C, RT>) {
         let id = self.tabs.add_tab(tab);
 
         if self.tabs.active == TabID::default() {
@@ -218,25 +221,27 @@ fn create_window(event_loop: &ActiveEventLoop) -> Result<Arc<WinitWindow>> {
 }
 
 pub(crate) struct WindowEventLoop<
-    D: SceneDrawer<B, L, LT, Doc, C>,
+    D: SceneDrawer<B, L, LT, Doc, C, RT>,
     B: RenderBackend,
     L: Layouter,
     LT: LayoutTree<L>,
     Doc: Document<C>,
     C: CssSystem,
+    RT: RenderTree<C>,
 > {
-    proxy: EventLoopProxy<CustomEventInternal<D, B, L, LT, Doc, C>>,
+    proxy: EventLoopProxy<CustomEventInternal<D, B, L, LT, Doc, C, RT>>,
     id: WindowId,
 }
 
 impl<
-        D: SceneDrawer<B, L, LT, Doc, C>,
+        D: SceneDrawer<B, L, LT, Doc, C, RT>,
         B: RenderBackend,
         L: Layouter,
         LT: LayoutTree<L>,
         Doc: Document<C>,
         C: CssSystem,
-    > Clone for WindowEventLoop<D, B, L, LT, Doc, C>
+        RT: RenderTree<C>,
+    > Clone for WindowEventLoop<D, B, L, LT, Doc, C, RT>
 {
     fn clone(&self) -> Self {
         Self {
@@ -247,13 +252,14 @@ impl<
 }
 
 impl<
-        D: SceneDrawer<B, L, LT, Doc, C>,
+        D: SceneDrawer<B, L, LT, Doc, C, RT>,
         B: RenderBackend,
         L: Layouter,
         LT: LayoutTree<L>,
         Doc: Document<C>,
         C: CssSystem,
-    > WindowedEventLoop<B> for WindowEventLoop<D, B, L, LT, Doc, C>
+        RT: RenderTree<C>,
+    > WindowedEventLoop<B, RT, C> for WindowEventLoop<D, B, L, LT, Doc, C, RT>
 {
     fn redraw(&mut self) {
         if let Err(e) = self.proxy.send_event(CustomEventInternal::Redraw(self.id)) {
@@ -269,4 +275,10 @@ impl<
             error!("Failed to send event {e}");
         }
     }
+
+    fn reload_from(&mut self, rt: RT) {
+        if let Err(e) = self.proxy.send_event(CustomEventInternal::ReloadFrom(rt, self.id)) {
+            error!("Failed to send event {e}");
+        }
+    }
 }
diff --git a/src/bin/renderer.rs b/src/bin/renderer.rs
index 76e798e09..3ba0d5292 100644
--- a/src/bin/renderer.rs
+++ b/src/bin/renderer.rs
@@ -50,7 +50,7 @@ fn main() -> Result<()> {
 
     // let mut rt = load_html_rendertree(&url)?;
     //
-    let mut application: Application<Drawer, Backend, Layouter, Tree, Document, CssSystem, HtmlParser> =
+    let mut application: Application<Drawer, Backend, Layouter, Tree, Document, CssSystem, HtmlParser, Tree> =
         Application::new(VelloBackend::new(), TaffyLayouter, debug);
 
     application.initial_tab(Url::parse(&url)?, WindowOptions::default());