diff --git a/examples/dyn-container/src/main.rs b/examples/dyn-container/src/main.rs
index 1fc32d26..26947466 100644
--- a/examples/dyn-container/src/main.rs
+++ b/examples/dyn-container/src/main.rs
@@ -44,8 +44,8 @@ fn app_view() -> impl View {
         dyn_container(
             move || view.get(),
             move |value| match value {
-                ViewSwitcher::One => Box::new(view_one()),
-                ViewSwitcher::Two => Box::new(view_two(view)),
+                ViewSwitcher::One => view_one().any(),
+                ViewSwitcher::Two => view_two(view).any(),
             },
         )
         .style(|s| s.padding(10).border(1)),
diff --git a/examples/flight_booker/src/main.rs b/examples/flight_booker/src/main.rs
index f573eec1..3fd710ab 100644
--- a/examples/flight_booker/src/main.rs
+++ b/examples/flight_booker/src/main.rs
@@ -85,11 +85,11 @@ pub fn app_view() -> impl View {
     let success_message = dyn_container(
         move || did_booking.get(),
         move |booked| match (booked, flight_mode.get()) {
-            (true, FlightMode::OneWay) => Box::new(text(oneway_message(start_text.get()))),
+            (true, FlightMode::OneWay) => text(oneway_message(start_text.get())).any(),
             (true, FlightMode::Return) => {
-                Box::new(text(return_message(start_text.get(), return_text.get())))
+                text(return_message(start_text.get(), return_text.get())).any()
             }
-            (false, _) => Box::new(empty()),
+            (false, _) => empty().any(),
         },
     );
 
diff --git a/src/action.rs b/src/action.rs
index de64ba34..9c94a246 100644
--- a/src/action.rs
+++ b/src/action.rs
@@ -15,7 +15,7 @@ use crate::{
     id::Id,
     menu::Menu,
     update::{UpdateMessage, CENTRAL_UPDATE_MESSAGES},
-    view::View,
+    view::Widget,
     window_handle::{get_current_view, set_current_view},
 };
 
@@ -165,7 +165,10 @@ pub fn set_ime_cursor_area(position: Point, size: Size) {
 }
 
 /// Creates a new overlay on the current window.
-pub fn add_overlay<V: View + 'static>(position: Point, view: impl FnOnce(Id) -> V + 'static) -> Id {
+pub fn add_overlay<V: Widget + 'static>(
+    position: Point,
+    view: impl FnOnce(Id) -> V + 'static,
+) -> Id {
     let id = Id::next();
     add_update_message(UpdateMessage::AddOverlay {
         id,
diff --git a/src/app.rs b/src/app.rs
index b3ffa6ad..e9aab9a7 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -10,8 +10,13 @@ use once_cell::sync::Lazy;
 use parking_lot::Mutex;
 
 use crate::{
-    action::Timer, app_handle::ApplicationHandle, clipboard::Clipboard, inspector::Capture,
-    profiler::Profile, view::View, window::WindowConfig,
+    action::Timer,
+    app_handle::ApplicationHandle,
+    clipboard::Clipboard,
+    inspector::Capture,
+    profiler::Profile,
+    view::{AnyView, View},
+    window::WindowConfig,
 };
 
 use raw_window_handle::HasRawDisplayHandle;
@@ -42,7 +47,7 @@ pub(crate) enum UserEvent {
 
 pub(crate) enum AppUpdateEvent {
     NewWindow {
-        view_fn: Box<dyn FnOnce(WindowId) -> Box<dyn View>>,
+        view_fn: Box<dyn FnOnce(WindowId) -> AnyView>,
         config: Option<WindowConfig>,
     },
     CloseWindow {
@@ -121,7 +126,7 @@ impl Application {
     ) -> Self {
         self.handle.as_mut().unwrap().new_window(
             &self.event_loop,
-            Box::new(|window_id| Box::new(app_view(window_id))),
+            Box::new(|window_id| app_view(window_id).any()),
             config,
         );
         self
diff --git a/src/app_handle.rs b/src/app_handle.rs
index 84b117ec..32e2ca39 100644
--- a/src/app_handle.rs
+++ b/src/app_handle.rs
@@ -14,7 +14,7 @@ use crate::{
     ext_event::EXT_EVENT_HANDLER,
     inspector::Capture,
     profiler::{Profile, ProfileEvent},
-    view::View,
+    view::AnyView,
     window::WindowConfig,
     window_handle::WindowHandle,
 };
@@ -239,7 +239,7 @@ impl ApplicationHandle {
     pub(crate) fn new_window(
         &mut self,
         event_loop: &EventLoopWindowTarget<UserEvent>,
-        view_fn: Box<dyn FnOnce(WindowId) -> Box<dyn View>>,
+        view_fn: Box<dyn FnOnce(WindowId) -> AnyView>,
         config: Option<WindowConfig>,
     ) {
         let mut window_builder = floem_winit::window::WindowBuilder::new();
diff --git a/src/context.rs b/src/context.rs
index b6d93b48..2d412194 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -26,7 +26,7 @@ use crate::{
         ZIndex,
     },
     unit::PxPct,
-    view::{paint_bg, paint_border, paint_outline, View, ViewData},
+    view::{paint_bg, paint_border, paint_outline, ViewData, Widget},
     view_data::ChangeFlags,
 };
 
@@ -172,12 +172,12 @@ impl AppState {
     }
 
     /// This removes a view from the app state.
-    pub fn remove_view(&mut self, view: &mut dyn View) {
+    pub fn remove_view(&mut self, view: &mut dyn Widget) {
         view.for_each_child_mut(&mut |child| {
             self.remove_view(child);
             false
         });
-        let id = view.id();
+        let id = view.view_data().id();
         let view_state = self.view_state(id);
         if let Some(action) = view_state.cleanup_listener.as_ref() {
             action();
@@ -597,11 +597,11 @@ impl<'a> EventCx<'a> {
     /// Internal method used by Floem. This can be called from parent `View`s to propagate an event to the child `View`.
     pub fn view_event(
         &mut self,
-        view: &mut dyn View,
+        view: &mut dyn Widget,
         id_path: Option<&[Id]>,
         event: Event,
     ) -> EventPropagation {
-        if self.should_send(view.id(), &event) {
+        if self.should_send(view.view_data().id(), &event) {
             self.unconditional_view_event(view, id_path, event)
         } else {
             EventPropagation::Continue
@@ -611,11 +611,11 @@ impl<'a> EventCx<'a> {
     /// Internal method used by Floem. This can be called from parent `View`s to propagate an event to the child `View`.
     pub(crate) fn unconditional_view_event(
         &mut self,
-        view: &mut dyn View,
+        view: &mut dyn Widget,
         id_path: Option<&[Id]>,
         event: Event,
     ) -> EventPropagation {
-        let id = view.id();
+        let id = view.view_data().id();
         if self.app_state.is_hidden(id) {
             // we don't process events for hidden view
             return EventPropagation::Continue;
@@ -645,7 +645,7 @@ impl<'a> EventCx<'a> {
             let id = id_path[0];
             let id_path = &id_path[1..];
 
-            if id != view.id() {
+            if id != view.view_data().id() {
                 // This shouldn't happen
                 return EventPropagation::Continue;
             }
@@ -1050,9 +1050,9 @@ impl<'a> StyleCx<'a> {
     }
 
     /// Internal method used by Floem to compute the styles for the view.
-    pub fn style_view(&mut self, view: &mut dyn View) {
+    pub fn style_view(&mut self, view: &mut dyn Widget) {
         self.save();
-        let id = view.id();
+        let id = view.view_data().id();
         let view_state = self.app_state_mut().view_state(id);
         if !view_state.requested_changes.contains(ChangeFlags::STYLE) {
             return;
@@ -1074,7 +1074,7 @@ impl<'a> StyleCx<'a> {
         if view_state.request_style_recursive {
             view_state.request_style_recursive = false;
             view.for_each_child(&mut |child| {
-                let state = self.app_state_mut().view_state(child.id());
+                let state = self.app_state_mut().view_state(child.view_data().id());
                 state.request_style_recursive = true;
                 state.requested_changes.insert(ChangeFlags::STYLE);
                 false
@@ -1255,8 +1255,8 @@ impl<'a> ComputeLayoutCx<'a> {
     /// - invoking any attached context::ResizeListeners
     ///
     /// Returns the bounding rect that encompasses this view and its children
-    pub fn compute_view_layout(&mut self, view: &mut dyn View) -> Option<Rect> {
-        let id = view.id();
+    pub fn compute_view_layout(&mut self, view: &mut dyn Widget) -> Option<Rect> {
+        let id = view.view_data().id();
         if self.app_state().is_hidden(id) {
             self.app_state_mut().view_state(id).layout_rect = Rect::ZERO;
             return None;
@@ -1381,7 +1381,7 @@ impl<'a> LayoutCx<'a> {
     }
 
     /// Internal method used by Floem to invoke the user-defined `View::layout` method.
-    pub fn layout_view(&mut self, view: &mut dyn View) -> Node {
+    pub fn layout_view(&mut self, view: &mut dyn Widget) -> Node {
         view.layout(self)
     }
 }
@@ -1427,8 +1427,8 @@ impl<'a> PaintCx<'a> {
     /// - managing hidden status
     /// - clipping
     /// - painting computed styles like background color, border, font-styles, and z-index and handling painting requirements of drag and drop
-    pub fn paint_view(&mut self, view: &mut dyn View) {
-        let id = view.id();
+    pub fn paint_view(&mut self, view: &mut dyn Widget) {
+        let id = view.view_data().id();
         if self.app_state.is_hidden(id) {
             return;
         }
@@ -1674,10 +1674,10 @@ impl<'a> UpdateCx<'a> {
 
     /// Used internally by Floem to send an update to the correct view based on the `Id` path.
     /// It will invoke only once `update` when the correct view is located.
-    pub fn update_view(&mut self, view: &mut dyn View, id_path: &[Id], state: Box<dyn Any>) {
+    pub fn update_view(&mut self, view: &mut dyn Widget, id_path: &[Id], state: Box<dyn Any>) {
         let id = id_path[0];
         let id_path = &id_path[1..];
-        if id == view.id() {
+        if id == view.view_data().id() {
             if id_path.is_empty() {
                 view.update(self, state);
             } else if let Some(child) = view.child_mut(id_path[0]) {
diff --git a/src/inspector.rs b/src/inspector.rs
index db96df72..7ab36a19 100644
--- a/src/inspector.rs
+++ b/src/inspector.rs
@@ -4,7 +4,7 @@ use crate::event::{Event, EventListener};
 use crate::id::Id;
 use crate::profiler::profiler;
 use crate::style::{Style, StyleMapValue};
-use crate::view::{view_children, View};
+use crate::view::{view_children, AnyView, View, Widget};
 use crate::view_data::ChangeFlags;
 use crate::views::{
     container, dyn_container, empty, h_stack, img_dynamic, scroll, stack, static_label, tab, text,
@@ -42,8 +42,8 @@ pub struct CapturedView {
 }
 
 impl CapturedView {
-    pub fn capture(view: &dyn View, app_state: &mut AppState, clip: Rect) -> Self {
-        let id = view.id();
+    pub fn capture(view: &dyn Widget, app_state: &mut AppState, clip: Rect) -> Self {
+        let id = view.view_data().id();
         let layout = app_state.get_layout_rect(id);
         let taffy = app_state.get_layout(id).unwrap();
         let computed_style = app_state.get_computed_style(id).clone();
@@ -142,28 +142,32 @@ fn captured_view_name(view: &CapturedView) -> impl View {
             .font_size(12.0)
             .color(Color::BLACK.with_alpha_factor(0.6))
     });
-    let tab: Box<dyn View> = if view.focused {
-        Box::new(text("Focus").style(|s| {
-            s.margin_right(5.0)
-                .background(Color::rgb8(63, 81, 101).with_alpha_factor(0.6))
-                .border_radius(5.0)
-                .padding(1.0)
-                .font_size(10.0)
-                .color(Color::WHITE.with_alpha_factor(0.8))
-        }))
+    let tab = if view.focused {
+        text("Focus")
+            .style(|s| {
+                s.margin_right(5.0)
+                    .background(Color::rgb8(63, 81, 101).with_alpha_factor(0.6))
+                    .border_radius(5.0)
+                    .padding(1.0)
+                    .font_size(10.0)
+                    .color(Color::WHITE.with_alpha_factor(0.8))
+            })
+            .any()
     } else if view.keyboard_navigable {
-        Box::new(text("Tab").style(|s| {
-            s.margin_right(5.0)
-                .background(Color::rgb8(204, 217, 221).with_alpha_factor(0.4))
-                .border(1.0)
-                .border_radius(5.0)
-                .border_color(Color::BLACK.with_alpha_factor(0.07))
-                .padding(1.0)
-                .font_size(10.0)
-                .color(Color::BLACK.with_alpha_factor(0.4))
-        }))
+        text("Tab")
+            .style(|s| {
+                s.margin_right(5.0)
+                    .background(Color::rgb8(204, 217, 221).with_alpha_factor(0.4))
+                    .border(1.0)
+                    .border_radius(5.0)
+                    .border_color(Color::BLACK.with_alpha_factor(0.07))
+                    .padding(1.0)
+                    .font_size(10.0)
+                    .color(Color::BLACK.with_alpha_factor(0.4))
+            })
+            .any()
     } else {
-        Box::new(empty())
+        empty().any()
     };
     h_stack((id, tab, name)).style(|s| s.items_center())
 }
@@ -174,7 +178,7 @@ fn captured_view_no_children(
     view: &CapturedView,
     depth: usize,
     capture_view: &CaptureView,
-) -> Box<dyn View> {
+) -> AnyView {
     let offset = depth as f64 * 14.0;
     let name = captured_view_name(view);
     let name_id = name.id();
@@ -183,33 +187,32 @@ fn captured_view_no_children(
     let selected = capture_view.selected;
     let highlighted = capture_view.highlighted;
 
-    let row = Box::new(
-        container(name)
-            .style(move |s| {
-                s.padding_left(20.0 + offset)
-                    .hover(move |s| {
-                        s.background(Color::rgba8(228, 237, 216, 160))
-                            .apply_if(selected.get() == Some(id), |s| {
-                                s.background(Color::rgb8(186, 180, 216))
-                            })
-                    })
-                    .height(height)
-                    .apply_if(highlighted.get() == Some(id), |s| {
-                        s.background(Color::rgba8(228, 237, 216, 160))
-                    })
-                    .apply_if(selected.get() == Some(id), |s| {
-                        if highlighted.get() == Some(id) {
+    let row = container(name)
+        .style(move |s| {
+            s.padding_left(20.0 + offset)
+                .hover(move |s| {
+                    s.background(Color::rgba8(228, 237, 216, 160))
+                        .apply_if(selected.get() == Some(id), |s| {
                             s.background(Color::rgb8(186, 180, 216))
-                        } else {
-                            s.background(Color::rgb8(213, 208, 216))
-                        }
-                    })
-            })
-            .on_click_stop(move |_| selected.set(Some(id)))
-            .on_event_cont(EventListener::PointerEnter, move |_| {
-                highlighted.set(Some(id))
-            }),
-    );
+                        })
+                })
+                .height(height)
+                .apply_if(highlighted.get() == Some(id), |s| {
+                    s.background(Color::rgba8(228, 237, 216, 160))
+                })
+                .apply_if(selected.get() == Some(id), |s| {
+                    if highlighted.get() == Some(id) {
+                        s.background(Color::rgb8(186, 180, 216))
+                    } else {
+                        s.background(Color::rgb8(213, 208, 216))
+                    }
+                })
+        })
+        .on_click_stop(move |_| selected.set(Some(id)))
+        .on_event_cont(EventListener::PointerEnter, move |_| {
+            highlighted.set(Some(id))
+        })
+        .any();
 
     let row_id = row.id();
     let scroll_to = capture_view.scroll_to;
@@ -233,8 +236,8 @@ fn captured_view_with_children(
     view: &Rc<CapturedView>,
     depth: usize,
     capture_view: &CaptureView,
-    children: Vec<Box<dyn View>>,
-) -> Box<dyn View> {
+    children: Vec<AnyView>,
+) -> AnyView {
     let offset = depth as f64 * 14.0;
     let name = captured_view_name(view);
     let height = 20.0;
@@ -335,14 +338,10 @@ fn captured_view_with_children(
 
     let list = v_stack((line, list));
 
-    Box::new(v_stack((row, list)))
+    v_stack((row, list)).any()
 }
 
-fn captured_view(
-    view: &Rc<CapturedView>,
-    depth: usize,
-    capture_view: &CaptureView,
-) -> Box<dyn View> {
+fn captured_view(view: &Rc<CapturedView>, depth: usize, capture_view: &CaptureView) -> AnyView {
     if view.children.is_empty() {
         captured_view_no_children(view, depth, capture_view)
     } else {
@@ -423,7 +422,7 @@ fn stats(capture: &Capture) -> impl View {
     ))
 }
 
-fn selected_view(capture: &Rc<Capture>, selected: RwSignal<Option<Id>>) -> impl View {
+fn selected_view(capture: &Rc<Capture>, selected: RwSignal<Option<Id>>) -> AnyView {
     let capture = capture.clone();
     dyn_container(
         move || selected.get(),
@@ -545,10 +544,10 @@ fn selected_view(capture: &Rc<Capture>, selected: RwSignal<Option<Id>>) -> impl
                 let style_list =
                     v_stack_from_iter(style_list.into_iter().map(|((prop, name), value)| {
                         let name = name.strip_prefix("floem::style::").unwrap_or(&name);
-                        let name: Box<dyn View> = if direct.contains(&prop) {
-                            Box::new(text(name))
+                        let name = if direct.contains(&prop) {
+                            text(name).any()
                         } else {
-                            Box::new(stack((
+                            stack((
                                 text("Inherited").style(|s| {
                                     s.margin_right(5.0)
                                         .background(Color::WHITE_SMOKE.with_alpha_factor(0.6))
@@ -560,16 +559,16 @@ fn selected_view(capture: &Rc<Capture>, selected: RwSignal<Option<Id>>) -> impl
                                         .color(Color::BLACK.with_alpha_factor(0.4))
                                 }),
                                 text(name),
-                            )))
+                            ))
+                            .any()
                         };
-                        let mut v: Box<dyn View> = match value {
+                        let mut v = match value {
                             StyleMapValue::Val(v) => {
                                 let v = &*v;
-                                (prop.info.debug_view)(v).unwrap_or_else(|| {
-                                    Box::new(static_label((prop.info.debug_any)(v)))
-                                })
+                                (prop.info.debug_view)(v)
+                                    .unwrap_or_else(|| static_label((prop.info.debug_any)(v)).any())
                             }
-                            StyleMapValue::Unset => Box::new(text("Unset")),
+                            StyleMapValue::Unset => text("Unset").any(),
                         };
                         if let Some(transition) = style.transitions.get(&prop).cloned() {
                             let transition = stack((
@@ -587,7 +586,7 @@ fn selected_view(capture: &Rc<Capture>, selected: RwSignal<Option<Id>>) -> impl
                                 static_label(format!("{transition:?}")),
                             ))
                             .style(|s| s.items_center());
-                            v = Box::new(v_stack((v, transition)));
+                            v = v_stack((v, transition)).any();
                         }
                         stack((
                             stack((name.style(|s| {
@@ -607,30 +606,30 @@ fn selected_view(capture: &Rc<Capture>, selected: RwSignal<Option<Id>>) -> impl
                     }))
                     .style(|s| s.width_full());
 
-                Box::new(
-                    v_stack((
-                        name,
-                        id,
-                        count,
-                        x,
-                        y,
-                        w,
-                        h,
-                        tx,
-                        ty,
-                        tw,
-                        th,
-                        clear,
-                        style_header,
-                        style_list,
-                    ))
-                    .style(|s| s.width_full()),
-                )
+                v_stack((
+                    name,
+                    id,
+                    count,
+                    x,
+                    y,
+                    w,
+                    h,
+                    tx,
+                    ty,
+                    tw,
+                    th,
+                    clear,
+                    style_header,
+                    style_list,
+                ))
+                .style(|s| s.width_full())
+                .any()
             } else {
-                Box::new(text("No selection").style(|s| s.padding(5.0)))
+                text("No selection").style(|s| s.padding(5.0)).any()
             }
         },
     )
+    .any()
 }
 
 #[derive(Clone, Copy)]
@@ -790,10 +789,10 @@ fn capture_view(capture: &Rc<Capture>) -> impl View {
         .on_click_stop(move |_| capture_view.selected.set(None))
         .scroll_to_view(move || capture_view.scroll_to.get());
 
-    let tree: Box<dyn View> = if capture.root.warnings() {
-        Box::new(v_stack((header("Warnings"), header("View Tree"), tree)))
+    let tree = if capture.root.warnings() {
+        v_stack((header("Warnings"), header("View Tree"), tree)).any()
     } else {
-        Box::new(v_stack((header("View Tree"), tree)))
+        v_stack((header("View Tree"), tree)).any()
     };
 
     let tree = tree.style(|s| s.height_full().min_width(0).flex_basis(0).flex_grow(1.0));
@@ -808,10 +807,10 @@ fn capture_view(capture: &Rc<Capture>) -> impl View {
 }
 
 fn inspector_view(capture: &Option<Rc<Capture>>) -> impl View {
-    let view: Box<dyn View> = if let Some(capture) = capture {
-        Box::new(capture_view(capture))
+    let view = if let Some(capture) = capture {
+        capture_view(capture).any()
     } else {
-        Box::new(text("No capture"))
+        text("No capture").any()
     };
 
     stack((view,))
@@ -835,7 +834,7 @@ fn inspector_view(capture: &Option<Rc<Capture>>) -> impl View {
 }
 
 thread_local! {
-    pub(crate) static RUNNING: Cell<bool> = Cell::new(false);
+    pub(crate) static RUNNING: Cell<bool> = const { Cell::new(false) };
     pub(crate) static CAPTURE: RwSignal<Option<Rc<Capture>>> = {
         Scope::new().create_rw_signal(None)
     };
@@ -876,18 +875,15 @@ pub fn capture(window_id: WindowId) {
                     move || selected.get(),
                     move || [0, 1].into_iter(),
                     |it| *it,
-                    move |it| -> Box<dyn View> {
-                        match it {
-                            0 => Box::new(
-                                dyn_container(
-                                    move || capture.get(),
-                                    |capture| Box::new(inspector_view(&capture)),
-                                )
-                                .style(|s| s.width_full().height_full()),
-                            ),
-                            1 => Box::new(profiler(window_id)),
-                            _ => panic!(),
-                        }
+                    move |it| match it {
+                        0 => dyn_container(
+                            move || capture.get(),
+                            |capture| inspector_view(&capture).any(),
+                        )
+                        .style(|s| s.width_full().height_full())
+                        .any(),
+                        1 => profiler(window_id).any(),
+                        _ => panic!(),
                     },
                 )
                 .style(|s| s.flex_basis(0.0).min_height(0.0).flex_grow(1.0));
diff --git a/src/nav.rs b/src/nav.rs
index b6d2aa1e..5142fbf7 100644
--- a/src/nav.rs
+++ b/src/nav.rs
@@ -4,10 +4,10 @@ use kurbo::{Point, Rect};
 use crate::{
     context::AppState,
     id::Id,
-    view::{view_tab_navigation, View},
+    view::{view_tab_navigation, Widget},
 };
 
-pub(crate) fn view_arrow_navigation(key: NamedKey, app_state: &mut AppState, view: &dyn View) {
+pub(crate) fn view_arrow_navigation(key: NamedKey, app_state: &mut AppState, view: &dyn Widget) {
     let focused = match app_state.focus {
         Some(id) => id,
         None => {
diff --git a/src/profiler.rs b/src/profiler.rs
index c76f44c2..bd557030 100644
--- a/src/profiler.rs
+++ b/src/profiler.rs
@@ -130,18 +130,19 @@ fn profile_view(profile: &Rc<Profile>) -> impl View {
 
     let event_tooltip = dyn_container(
         move || hovered_event.get(),
-        move |event: Option<ProfileEvent>| -> Box<dyn View> {
+        move |event: Option<ProfileEvent>| {
             if let Some(event) = event {
                 let len = event
                     .end
                     .saturating_duration_since(event.start)
                     .as_secs_f64();
-                Box::new(v_stack((
+                v_stack((
                     info("Name", event.name.to_string()),
                     info("Time", format!("{:.4} ms", len * 1000.0)),
-                )))
+                ))
+                .any()
             } else {
-                Box::new(text("No hovered event").style(|s| s.padding(5.0)))
+                text("No hovered event").style(|s| s.padding(5.0)).any()
             }
         },
     )
@@ -204,23 +205,22 @@ fn profile_view(profile: &Rc<Profile>) -> impl View {
                         hovered_event.set(Some(event_.clone()))
                     })
                 });
-                Box::new(
-                    scroll(
-                        v_stack_from_iter(list)
-                            .style(move |s| s.min_width_pct(zoom.get() * 100.0).height_full()),
-                    )
-                    .style(|s| s.height_full().min_width(0).flex_basis(0).flex_grow(1.0))
-                    .on_event(EventListener::PointerWheel, move |e| {
-                        if let Event::PointerWheel(e) = e {
-                            zoom.set(zoom.get() * (1.0 - e.delta.y / 400.0));
-                            EventPropagation::Stop
-                        } else {
-                            EventPropagation::Continue
-                        }
-                    }),
+                scroll(
+                    v_stack_from_iter(list)
+                        .style(move |s| s.min_width_pct(zoom.get() * 100.0).height_full()),
                 )
+                .style(|s| s.height_full().min_width(0).flex_basis(0).flex_grow(1.0))
+                .on_event(EventListener::PointerWheel, move |e| {
+                    if let Event::PointerWheel(e) = e {
+                        zoom.set(zoom.get() * (1.0 - e.delta.y / 400.0));
+                        EventPropagation::Stop
+                    } else {
+                        EventPropagation::Continue
+                    }
+                })
+                .any()
             } else {
-                Box::new(text("No selected frame").style(|s| s.padding(5.0)))
+                text("No selected frame").style(|s| s.padding(5.0)).any()
             }
         },
     )
@@ -282,9 +282,9 @@ pub fn profiler(window_id: WindowId) -> impl View {
         move || profile.get(),
         |profile| {
             if let Some(profile) = profile {
-                Box::new(profile_view(&profile))
+                profile_view(&profile).any()
             } else {
-                Box::new(text("No profile").style(|s| s.padding(5.0)))
+                text("No profile").style(|s| s.padding(5.0)).any()
             }
         },
     )
diff --git a/src/style.rs b/src/style.rs
index 74689228..b485b7d4 100644
--- a/src/style.rs
+++ b/src/style.rs
@@ -53,11 +53,11 @@ use taffy::{
 use crate::context::InteractionState;
 use crate::responsive::{ScreenSize, ScreenSizeBp};
 use crate::unit::{Px, PxPct, PxPctAuto, UnitExt};
-use crate::view::View;
+use crate::view::{AnyView, View};
 use crate::views::{empty, stack, text, Decorators};
 
 pub trait StylePropValue: Clone + PartialEq + Debug {
-    fn debug_view(&self) -> Option<Box<dyn View>> {
+    fn debug_view(&self) -> Option<AnyView> {
         None
     }
 
@@ -96,7 +96,7 @@ impl StylePropValue for LineHeightValue {}
 impl StylePropValue for Size<LengthPercentage> {}
 
 impl<T: StylePropValue> StylePropValue for Option<T> {
-    fn debug_view(&self) -> Option<Box<dyn View>> {
+    fn debug_view(&self) -> Option<AnyView> {
         self.as_ref().and_then(|v| v.debug_view())
     }
 
@@ -109,7 +109,7 @@ impl<T: StylePropValue> StylePropValue for Option<T> {
     }
 }
 impl<T: StylePropValue> StylePropValue for Vec<T> {
-    fn debug_view(&self) -> Option<Box<dyn View>> {
+    fn debug_view(&self) -> Option<AnyView> {
         None
     }
 
@@ -118,34 +118,34 @@ impl<T: StylePropValue> StylePropValue for Vec<T> {
     }
 }
 impl StylePropValue for Px {
-    fn debug_view(&self) -> Option<Box<dyn View>> {
-        Some(Box::new(text(format!("{} px", self.0))))
+    fn debug_view(&self) -> Option<AnyView> {
+        Some(text(format!("{} px", self.0)).any())
     }
     fn interpolate(&self, other: &Self, value: f64) -> Option<Self> {
         self.0.interpolate(&other.0, value).map(Px)
     }
 }
 impl StylePropValue for PxPctAuto {
-    fn debug_view(&self) -> Option<Box<dyn View>> {
+    fn debug_view(&self) -> Option<AnyView> {
         let label = match self {
             Self::Px(v) => format!("{} px", v),
             Self::Pct(v) => format!("{}%", v),
             Self::Auto => "auto".to_string(),
         };
-        Some(Box::new(text(label)))
+        Some(text(label).any())
     }
 }
 impl StylePropValue for PxPct {
-    fn debug_view(&self) -> Option<Box<dyn View>> {
+    fn debug_view(&self) -> Option<AnyView> {
         let label = match self {
             Self::Px(v) => format!("{} px", v),
             Self::Pct(v) => format!("{}%", v),
         };
-        Some(Box::new(text(label)))
+        Some(text(label).any())
     }
 }
 impl StylePropValue for Color {
-    fn debug_view(&self) -> Option<Box<dyn View>> {
+    fn debug_view(&self) -> Option<AnyView> {
         let color = *self;
         let color = empty().style(move |s| {
             s.background(color)
@@ -161,9 +161,11 @@ impl StylePropValue for Color {
                 .border_radius(5.0)
                 .margin_left(6.0)
         });
-        Some(Box::new(
-            stack((text(format!("{self:?}")), color)).style(|s| s.items_center()),
-        ))
+        Some(
+            stack((text(format!("{self:?}")), color))
+                .style(|s| s.items_center())
+                .any(),
+        )
     }
 
     fn interpolate(&self, other: &Self, value: f64) -> Option<Self> {
@@ -247,7 +249,7 @@ pub struct StylePropInfo {
     pub(crate) inherited: bool,
     pub(crate) default_as_any: fn() -> Rc<dyn Any>,
     pub(crate) debug_any: fn(val: &dyn Any) -> String,
-    pub(crate) debug_view: fn(val: &dyn Any) -> Option<Box<dyn View>>,
+    pub(crate) debug_view: fn(val: &dyn Any) -> Option<AnyView>,
 }
 
 impl StylePropInfo {
diff --git a/src/update.rs b/src/update.rs
index 4a9c1477..1caf4532 100644
--- a/src/update.rs
+++ b/src/update.rs
@@ -10,7 +10,7 @@ use crate::{
     id::Id,
     menu::Menu,
     style::{Style, StyleClassRef, StyleSelector},
-    view::View,
+    view::Widget,
     view_data::{ChangeFlags, StackOffset},
 };
 
@@ -116,7 +116,7 @@ pub(crate) enum UpdateMessage {
     AddOverlay {
         id: Id,
         position: Point,
-        view: Box<dyn FnOnce() -> Box<dyn View>>,
+        view: Box<dyn FnOnce() -> Box<dyn Widget>>,
     },
     RemoveOverlay {
         id: Id,
diff --git a/src/view.rs b/src/view.rs
index 2fd93105..f5fb4c9e 100644
--- a/src/view.rs
+++ b/src/view.rs
@@ -99,30 +99,92 @@ use crate::{
 
 pub use crate::view_data::ViewData;
 
-pub trait View {
+pub type AnyWidget = Box<dyn Widget>;
+
+pub trait View: Sized {
+    fn view_data(&self) -> &ViewData;
+    fn view_data_mut(&mut self) -> &mut ViewData;
+
+    fn id(&self) -> Id {
+        self.view_data().id()
+    }
+
+    /// This method builds the widget described by the view. Implementations may not assume that an
+    /// implicit scope is available. It may differ from the scope the view was created in or may not
+    /// be available at all.
+    fn build(self) -> AnyWidget;
+
+    /// Converts this view into the `AnyView` type.
+    fn any(self) -> AnyView
+    where
+        Self: 'static,
+    {
+        AnyView {
+            view: Box::new(self),
+        }
+    }
+}
+
+/// This is a type which can hold any view.
+pub struct AnyView {
+    view: Box<dyn DynView>,
+}
+
+impl View for AnyView {
+    fn view_data(&self) -> &ViewData {
+        self.view.view_data()
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        self.view.view_data_mut()
+    }
+
+    fn build(self) -> AnyWidget {
+        self.view.build()
+    }
+}
+
+trait DynView {
+    fn view_data(&self) -> &ViewData;
+    fn view_data_mut(&mut self) -> &mut ViewData;
+    fn build(self: Box<Self>) -> Box<dyn Widget>;
+}
+
+impl<V: View> DynView for V {
+    fn view_data(&self) -> &ViewData {
+        self.view_data()
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        self.view_data_mut()
+    }
+
+    fn build(self: Box<Self>) -> Box<dyn Widget> {
+        View::build(*self)
+    }
+}
+
+pub trait Widget {
     fn view_data(&self) -> &ViewData;
     fn view_data_mut(&mut self) -> &mut ViewData;
 
     /// This method walks over children and must be implemented if the view has any children.
     /// It should return children back to front and should stop if `_for_each` returns `true`.
-    fn for_each_child<'a>(&'a self, _for_each: &mut dyn FnMut(&'a dyn View) -> bool) {}
+    fn for_each_child<'a>(&'a self, _for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {}
 
     /// This method walks over children and must be implemented if the view has any children.
     /// It should return children back to front and should stop if `_for_each` returns `true`.
-    fn for_each_child_mut<'a>(&'a mut self, _for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {}
+    fn for_each_child_mut<'a>(&'a mut self, _for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
+    }
 
     /// This method walks over children and must be implemented if the view has any children.
     /// It should return children front to back and should stop if `_for_each` returns `true`.
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        _for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        _for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
     }
 
-    fn id(&self) -> Id {
-        self.view_data().id()
-    }
-
     fn view_style(&self) -> Option<Style> {
         None
     }
@@ -131,10 +193,10 @@ pub trait View {
         None
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
+    fn child(&self, id: Id) -> Option<&dyn Widget> {
         let mut result = None;
         self.for_each_child(&mut |view| {
-            if view.id() == id {
+            if view.view_data().id() == id {
                 result = Some(view);
                 true
             } else {
@@ -144,10 +206,10 @@ pub trait View {
         result
     }
 
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
+    fn child_mut(&mut self, id: Id) -> Option<&mut dyn Widget> {
         let mut result = None;
         self.for_each_child_mut(&mut |view| {
-            if view.id() == id {
+            if view.view_data().id() == id {
                 result = Some(view);
                 true
             } else {
@@ -191,7 +253,7 @@ pub trait View {
     /// If the layout changes needs other passes to run you're expected to call
     /// `cx.app_state_mut().request_changes`.
     fn layout(&mut self, cx: &mut LayoutCx) -> Node {
-        cx.layout_node(self.id(), true, |cx| {
+        cx.layout_node(self.view_data().id(), true, |cx| {
             let mut nodes = Vec::new();
             self.for_each_child_mut(&mut |child| {
                 nodes.push(cx.layout_view(child));
@@ -237,7 +299,7 @@ pub trait View {
     /// Scrolls the view and all direct and indirect children to bring the `target` view to be
     /// visible. Returns true if this view contains or is the target.
     fn scroll_to(&mut self, cx: &mut AppState, target: Id, rect: Option<Rect>) -> bool {
-        if self.id() == target {
+        if self.view_data().id() == target {
             return true;
         }
         let mut found = false;
@@ -250,7 +312,7 @@ pub trait View {
 }
 
 /// Computes the layout of the view's children, if any.
-pub fn default_compute_layout<V: View + ?Sized>(
+pub fn default_compute_layout<V: Widget + ?Sized>(
     view: &mut V,
     cx: &mut ComputeLayoutCx,
 ) -> Option<Rect> {
@@ -269,7 +331,7 @@ pub fn default_compute_layout<V: View + ?Sized>(
     layout_rect
 }
 
-pub fn default_event<V: View + ?Sized>(
+pub fn default_event<V: Widget + ?Sized>(
     view: &mut V,
     cx: &mut EventCx,
     id_path: Option<&[Id]>,
@@ -443,7 +505,7 @@ pub(crate) fn paint_border(cx: &mut PaintCx, style: &ViewStyleProps, size: Size)
     }
 }
 
-pub(crate) fn view_children(view: &dyn View) -> Vec<&dyn View> {
+pub(crate) fn view_children(view: &dyn Widget) -> Vec<&dyn Widget> {
     let mut result = Vec::new();
     view.for_each_child(&mut |view| {
         result.push(view);
@@ -454,11 +516,15 @@ pub(crate) fn view_children(view: &dyn View) -> Vec<&dyn View> {
 
 /// Tab navigation finds the next or previous view with the `keyboard_navigatable` status in the tree.
 #[allow(dead_code)]
-pub(crate) fn view_tab_navigation(root_view: &dyn View, app_state: &mut AppState, backwards: bool) {
+pub(crate) fn view_tab_navigation(
+    root_view: &dyn Widget,
+    app_state: &mut AppState,
+    backwards: bool,
+) {
     let start = app_state
         .focus
         .filter(|id| id.id_path().is_some())
-        .unwrap_or(root_view.id());
+        .unwrap_or(root_view.view_data().id());
 
     assert!(
         view_filtered_children(root_view, start.id_path().unwrap().dispatch()).is_some(),
@@ -468,9 +534,9 @@ pub(crate) fn view_tab_navigation(root_view: &dyn View, app_state: &mut AppState
     let tree_iter = |id: Id| {
         if backwards {
             view_tree_previous(root_view, &id)
-                .unwrap_or_else(|| view_nested_last_child(root_view).id())
+                .unwrap_or_else(|| view_nested_last_child(root_view).view_data().id())
         } else {
-            view_tree_next(root_view, &id).unwrap_or(root_view.id())
+            view_tree_next(root_view, &id).unwrap_or(root_view.view_data().id())
         }
     };
 
@@ -483,11 +549,11 @@ pub(crate) fn view_tab_navigation(root_view: &dyn View, app_state: &mut AppState
     app_state.update_focus(new_focus, true);
 }
 
-fn view_filtered_children<'a>(view: &'a dyn View, id_path: &[Id]) -> Option<Vec<&'a dyn View>> {
+fn view_filtered_children<'a>(view: &'a dyn Widget, id_path: &[Id]) -> Option<Vec<&'a dyn Widget>> {
     let id = id_path[0];
     let id_path = &id_path[1..];
 
-    if id == view.id() {
+    if id == view.view_data().id() {
         if id_path.is_empty() {
             Some(view_children(view))
         } else if let Some(child) = view.child(id_path[0]) {
@@ -501,7 +567,7 @@ fn view_filtered_children<'a>(view: &'a dyn View, id_path: &[Id]) -> Option<Vec<
 }
 
 /// Get the next item in the tree, either the first child or the next sibling of this view or of the first parent view
-fn view_tree_next(root_view: &dyn View, id: &Id) -> Option<Id> {
+fn view_tree_next(root_view: &dyn Widget, id: &Id) -> Option<Id> {
     let id_path = id.id_path().unwrap();
 
     if let Some(child) = view_filtered_children(root_view, id_path.dispatch())
@@ -509,7 +575,7 @@ fn view_tree_next(root_view: &dyn View, id: &Id) -> Option<Id> {
         .into_iter()
         .next()
     {
-        return Some(child.id());
+        return Some(child.view_data().id());
     }
 
     let mut ancestor = *id;
@@ -519,14 +585,14 @@ fn view_tree_next(root_view: &dyn View, id: &Id) -> Option<Id> {
             return None;
         }
         if let Some(next_sibling) = view_next_sibling(root_view, id_path.dispatch()) {
-            return Some(next_sibling.id());
+            return Some(next_sibling.view_data().id());
         }
         ancestor = ancestor.parent()?;
     }
 }
 
 /// Get the id of the view after this one (but with the same parent and level of nesting)
-fn view_next_sibling<'a>(root_view: &'a dyn View, id_path: &[Id]) -> Option<&'a dyn View> {
+fn view_next_sibling<'a>(root_view: &'a dyn Widget, id_path: &[Id]) -> Option<&'a dyn Widget> {
     let id = *id_path.last().unwrap();
     let parent = &id_path[0..(id_path.len() - 1)];
 
@@ -536,7 +602,10 @@ fn view_next_sibling<'a>(root_view: &'a dyn View, id_path: &[Id]) -> Option<&'a
     }
 
     let children = view_filtered_children(root_view, parent).unwrap();
-    let pos = children.iter().position(|v| v.id() == id).unwrap();
+    let pos = children
+        .iter()
+        .position(|v| v.view_data().id() == id)
+        .unwrap();
 
     if pos + 1 < children.len() {
         Some(children[pos + 1])
@@ -546,21 +615,21 @@ fn view_next_sibling<'a>(root_view: &'a dyn View, id_path: &[Id]) -> Option<&'a
 }
 
 /// Get the next item in the tree, the deepest last child of the previous sibling of this view or the parent
-fn view_tree_previous(root_view: &dyn View, id: &Id) -> Option<Id> {
+fn view_tree_previous(root_view: &dyn Widget, id: &Id) -> Option<Id> {
     let id_path = id.id_path().unwrap();
 
     view_previous_sibling(root_view, id_path.dispatch())
-        .map(|view| view_nested_last_child(view).id())
+        .map(|view| view_nested_last_child(view).view_data().id())
         .or_else(|| {
-            (root_view.id() != *id).then_some(
+            (root_view.view_data().id() != *id).then_some(
                 id.parent()
-                    .unwrap_or_else(|| view_nested_last_child(root_view).id()),
+                    .unwrap_or_else(|| view_nested_last_child(root_view).view_data().id()),
             )
         })
 }
 
 /// Get the id of the view before this one (but with the same parent and level of nesting)
-fn view_previous_sibling<'a>(root_view: &'a dyn View, id_path: &[Id]) -> Option<&'a dyn View> {
+fn view_previous_sibling<'a>(root_view: &'a dyn Widget, id_path: &[Id]) -> Option<&'a dyn Widget> {
     let id = *id_path.last().unwrap();
     let parent = &id_path[0..(id_path.len() - 1)];
 
@@ -570,7 +639,10 @@ fn view_previous_sibling<'a>(root_view: &'a dyn View, id_path: &[Id]) -> Option<
     }
 
     let children = view_filtered_children(root_view, parent).unwrap();
-    let pos = children.iter().position(|v| v.id() == id).unwrap();
+    let pos = children
+        .iter()
+        .position(|v| v.view_data().id() == id)
+        .unwrap();
 
     if pos > 0 {
         Some(children[pos - 1])
@@ -579,16 +651,16 @@ fn view_previous_sibling<'a>(root_view: &'a dyn View, id_path: &[Id]) -> Option<
     }
 }
 
-pub(crate) fn view_children_set_parent_id(view: &dyn View) {
-    let parent_id = view.id();
+pub(crate) fn view_children_set_parent_id(view: &dyn Widget) {
+    let parent_id = view.view_data().id();
     view.for_each_child(&mut |child| {
-        child.id().set_parent(parent_id);
+        child.view_data().id().set_parent(parent_id);
         view_children_set_parent_id(child);
         false
     });
 }
 
-fn view_nested_last_child(view: &dyn View) -> &dyn View {
+fn view_nested_last_child(view: &dyn Widget) -> &dyn Widget {
     let mut last_child = view;
     while let Some(new_last_child) = view_children(last_child).pop() {
         last_child = new_last_child;
@@ -598,7 +670,7 @@ fn view_nested_last_child(view: &dyn View) -> &dyn View {
 
 /// Produces an ascii art debug display of all of the views.
 #[allow(dead_code)]
-pub(crate) fn view_debug_tree(root_view: &dyn View) {
+pub(crate) fn view_debug_tree(root_view: &dyn Widget) {
     let mut views = vec![(root_view, Vec::new())];
     while let Some((current_view, active_lines)) = views.pop() {
         // Ascii art for the tree view
@@ -608,7 +680,11 @@ pub(crate) fn view_debug_tree(root_view: &dyn View) {
             }
             print!("{}", if *leaf { "├── " } else { "└── " });
         }
-        println!("{:?} {}", current_view.id(), &current_view.debug_name());
+        println!(
+            "{:?} {}",
+            current_view.view_data().id(),
+            &current_view.debug_name()
+        );
 
         let mut children = view_children(current_view);
         if let Some(last_child) = children.pop() {
@@ -624,7 +700,7 @@ pub(crate) fn view_debug_tree(root_view: &dyn View) {
     }
 }
 
-impl View for Box<dyn View> {
+impl Widget for Box<dyn Widget> {
     fn view_data(&self) -> &ViewData {
         (**self).view_data()
     }
@@ -633,25 +709,21 @@ impl View for Box<dyn View> {
         (**self).view_data_mut()
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         (**self).for_each_child(for_each)
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         (**self).for_each_child_mut(for_each)
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         (**self).for_each_child_rev_mut(for_each)
     }
 
-    fn id(&self) -> Id {
-        (**self).id()
-    }
-
     fn view_style(&self) -> Option<Style> {
         (**self).view_style()
     }
@@ -660,11 +732,11 @@ impl View for Box<dyn View> {
         (**self).view_class()
     }
 
-    fn child(&self, id: Id) -> Option<&dyn View> {
+    fn child(&self, id: Id) -> Option<&dyn Widget> {
         (**self).child(id)
     }
 
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
+    fn child_mut(&mut self, id: Id) -> Option<&mut dyn Widget> {
         (**self).child_mut(id)
     }
 
diff --git a/src/view_data.rs b/src/view_data.rs
index c10a6535..04519eac 100644
--- a/src/view_data.rs
+++ b/src/view_data.rs
@@ -10,7 +10,7 @@ use crate::{
         Background, BorderBottom, BorderColor, BorderLeft, BorderRadius, BorderRight, BorderTop,
         LayoutProps, Outline, OutlineColor, Style, StyleClassRef, StyleSelectors,
     },
-    view::View,
+    view::Widget,
 };
 use bitflags::bitflags;
 use kurbo::Rect;
@@ -88,11 +88,15 @@ impl ViewData {
     }
 }
 
-pub(crate) fn update_data(id: Id, root: &mut dyn View, f: impl FnOnce(&mut ViewData)) {
-    pub(crate) fn update_inner(id_path: &[Id], view: &mut dyn View, f: impl FnOnce(&mut ViewData)) {
+pub(crate) fn update_data(id: Id, root: &mut dyn Widget, f: impl FnOnce(&mut ViewData)) {
+    pub(crate) fn update_inner(
+        id_path: &[Id],
+        view: &mut dyn Widget,
+        f: impl FnOnce(&mut ViewData),
+    ) {
         let id = id_path[0];
         let id_path = &id_path[1..];
-        if id == view.id() {
+        if id == view.view_data().id() {
             if id_path.is_empty() {
                 f(view.view_data_mut());
             } else if let Some(child) = view.child_mut(id_path[0]) {
diff --git a/src/view_tuple.rs b/src/view_tuple.rs
index e4b4f246..ef7ce962 100644
--- a/src/view_tuple.rs
+++ b/src/view_tuple.rs
@@ -1,25 +1,8 @@
-use crate::context::PaintCx;
-use crate::id::Id;
 use crate::view::View;
+use crate::view::Widget;
 
 pub trait ViewTuple {
-    fn paint(&mut self, cx: &mut PaintCx);
-
-    fn foreach<F: Fn(&dyn View)>(&self, f: F);
-
-    fn foreach_mut<F: FnMut(&mut dyn View) -> bool>(&mut self, f: &mut F);
-
-    fn foreach_rev<F: FnMut(&mut dyn View) -> bool>(&mut self, f: &mut F);
-
-    fn child(&self, id: Id) -> Option<&dyn View>;
-
-    fn child_mut(&mut self, id: Id) -> Option<&mut dyn View>;
-
-    fn children(&self) -> Vec<&dyn View>;
-
-    fn children_mut(&mut self) -> Vec<&mut dyn View>;
-
-    fn into_views(self) -> Vec<Box<dyn View>>
+    fn into_widgets(self) -> Vec<Box<dyn Widget>>
     where
         Self: 'static;
 }
@@ -28,47 +11,11 @@ macro_rules! impl_view_tuple {
     ( $n: tt; $( $t:ident),* ; $( $i:tt ),* ; $( $j:tt ),*) => {
 
         impl< $( $t: View, )* > ViewTuple for ( $( $t, )* ) {
-            fn foreach<F: Fn(&dyn View)>(&self, f: F) {
-                $( f(&self.$i); )*
-            }
-
-            fn foreach_mut<F: FnMut(&mut dyn View) -> bool>(&mut self, f: &mut F) {
-                $( if f(&mut self.$i) { return; } )*
-            }
-
-            fn foreach_rev<F: FnMut(&mut dyn View) -> bool>(&mut self, f: &mut F) {
-                $( if f(&mut self.$j) { return; } )*
-            }
-
-            fn child(&self, id: Id) -> Option<&dyn View> {
-                $( if self.$i.id() == id { return Some(&self.$i) } )*
-                None
-            }
-
-            fn child_mut(&mut self, id: Id) -> Option<&mut dyn View> {
-                $( if self.$i.id() == id { return Some(&mut self.$i) } )*
-                None
-            }
-
-            fn children(&self) -> Vec<&dyn View> {
-                vec![ $( &self.$i ),* ]
-            }
-
-            fn children_mut(&mut self) -> Vec<&mut dyn View> {
-                vec![ $( &mut self.$i ),* ]
-            }
-
-            fn paint(&mut self, cx: &mut PaintCx) {
-                $(
-                    self.$i.paint(cx);
-                )*
-            }
-
-            fn into_views(self) -> Vec<Box<dyn View>>
+            fn into_widgets(self) -> Vec<Box<dyn Widget>>
             where
                 Self: 'static
             {
-                vec![$(Box::new(self.$i),)*]
+                vec![$(self.$i.build(),)*]
             }
         }
     }
diff --git a/src/views/clip.rs b/src/views/clip.rs
index 1b0615fb..47c281b5 100644
--- a/src/views/clip.rs
+++ b/src/views/clip.rs
@@ -2,18 +2,18 @@ use kurbo::Size;
 
 use crate::{
     id::Id,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
 };
 
 pub struct Clip {
     data: ViewData,
-    child: Box<dyn View>,
+    child: Box<dyn Widget>,
 }
 
 pub fn clip<V: View + 'static>(child: V) -> Clip {
     Clip {
         data: ViewData::new(Id::next()),
-        child: Box::new(child),
+        child: child.build(),
     }
 }
 
@@ -26,17 +26,31 @@ impl View for Clip {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for Clip {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
diff --git a/src/views/container.rs b/src/views/container.rs
index fdc46614..7d4a83df 100644
--- a/src/views/container.rs
+++ b/src/views/container.rs
@@ -1,12 +1,12 @@
 use crate::{
     id::Id,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
 };
 
 /// A simple wrapper around another View. See [`container`]
 pub struct Container {
     data: ViewData,
-    child: Box<dyn View>,
+    child: Box<dyn Widget>,
 }
 
 /// A simple wrapper around another View
@@ -16,7 +16,7 @@ pub struct Container {
 pub fn container<V: View + 'static>(child: V) -> Container {
     Container {
         data: ViewData::new(Id::next()),
-        child: Box::new(child),
+        child: child.build(),
     }
 }
 
@@ -29,17 +29,31 @@ impl View for Container {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for Container {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
diff --git a/src/views/container_box.rs b/src/views/container_box.rs
index e08d6a8b..2d3cc871 100644
--- a/src/views/container_box.rs
+++ b/src/views/container_box.rs
@@ -1,12 +1,12 @@
 use crate::{
     id::Id,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
 };
 
 /// A wrapper around any type that implements View. See [`container_box`]
 pub struct ContainerBox {
     data: ViewData,
-    child: Box<dyn View>,
+    child: Box<dyn Widget>,
 }
 
 /// A wrapper around any type that implements View.
@@ -47,7 +47,7 @@ pub struct ContainerBox {
 pub fn container_box(child: impl View + 'static) -> ContainerBox {
     ContainerBox {
         data: ViewData::new(Id::next()),
-        child: Box::new(child),
+        child: child.build(),
     }
 }
 
@@ -60,17 +60,31 @@ impl View for ContainerBox {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for ContainerBox {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
diff --git a/src/views/drag_resize_window_area.rs b/src/views/drag_resize_window_area.rs
index 70b947ba..1ec49b89 100644
--- a/src/views/drag_resize_window_area.rs
+++ b/src/views/drag_resize_window_area.rs
@@ -5,17 +5,17 @@ use crate::{
     event::EventListener,
     id::Id,
     style::CursorStyle,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
 };
 
 use super::Decorators;
 
 pub struct DragResizeWindowArea {
     data: ViewData,
-    child: Box<dyn View>,
+    child: Box<dyn Widget>,
 }
 
-pub fn drag_resize_window_area<V: View + 'static>(
+pub fn drag_resize_window_area<V: Widget + 'static>(
     direction: ResizeDirection,
     child: V,
 ) -> DragResizeWindowArea {
@@ -50,17 +50,31 @@ impl View for DragResizeWindowArea {
     fn view_data_mut(&mut self) -> &mut ViewData {
         &mut self.data
     }
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for DragResizeWindowArea {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
diff --git a/src/views/drag_window_area.rs b/src/views/drag_window_area.rs
index 76a037db..c670ae74 100644
--- a/src/views/drag_window_area.rs
+++ b/src/views/drag_window_area.rs
@@ -2,17 +2,17 @@ use crate::{
     action::{drag_window, toggle_window_maximized},
     event::EventListener,
     id::Id,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
 };
 
 use super::Decorators;
 
 pub struct DragWindowArea {
     data: ViewData,
-    child: Box<dyn View>,
+    child: Box<dyn Widget>,
 }
 
-pub fn drag_window_area<V: View + 'static>(child: V) -> DragWindowArea {
+pub fn drag_window_area<V: Widget + 'static>(child: V) -> DragWindowArea {
     let id = Id::next();
     DragWindowArea {
         data: ViewData::new(id),
@@ -31,17 +31,31 @@ impl View for DragWindowArea {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for DragWindowArea {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
diff --git a/src/views/dyn_container.rs b/src/views/dyn_container.rs
index 99826218..13b20186 100644
--- a/src/views/dyn_container.rs
+++ b/src/views/dyn_container.rs
@@ -2,15 +2,15 @@ use floem_reactive::{as_child_of_current_scope, create_updater, Scope};
 
 use crate::{
     id::Id,
-    view::{view_children_set_parent_id, View, ViewData},
+    view::{view_children_set_parent_id, AnyView, View, ViewData, Widget},
 };
 
-type ChildFn<T> = dyn Fn(T) -> (Box<dyn View>, Scope);
+type ChildFn<T> = dyn Fn(T) -> (Box<dyn Widget>, Scope);
 
 /// A container for a dynamically updating View. See [`dyn_container`]
 pub struct DynamicContainer<T: 'static> {
     data: ViewData,
-    child: Box<dyn View>,
+    child: Box<dyn Widget>,
     child_scope: Scope,
     child_fn: Box<ChildFn<T>>,
 }
@@ -67,7 +67,7 @@ pub struct DynamicContainer<T: 'static> {
 /// ```
 ///
 /// See [container_box](crate::views::container_box()) for more documentation on a general container
-pub fn dyn_container<CF: Fn(T) -> Box<dyn View> + 'static, T: 'static>(
+pub fn dyn_container<CF: Fn(T) -> AnyView + 'static, T: 'static>(
     update_view: impl Fn() -> T + 'static,
     child_fn: CF,
 ) -> DynamicContainer<T> {
@@ -75,7 +75,7 @@ pub fn dyn_container<CF: Fn(T) -> Box<dyn View> + 'static, T: 'static>(
 
     let initial = create_updater(update_view, move |new_state| id.update_state(new_state));
 
-    let child_fn = Box::new(as_child_of_current_scope(child_fn));
+    let child_fn = Box::new(as_child_of_current_scope(move |e| child_fn(e).build()));
     let (child, child_scope) = child_fn(initial);
     DynamicContainer {
         data: ViewData::new(id),
@@ -94,17 +94,31 @@ impl<T: 'static> View for DynamicContainer<T> {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl<T: 'static> Widget for DynamicContainer<T> {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
@@ -119,7 +133,7 @@ impl<T: 'static> View for DynamicContainer<T> {
             cx.app_state_mut().remove_view(&mut self.child);
             (self.child, self.child_scope) = (self.child_fn)(*val);
             old_child_scope.dispose();
-            self.child.id().set_parent(self.id());
+            self.child.view_data().id().set_parent(self.id());
             view_children_set_parent_id(&*self.child);
             cx.request_all(self.id());
         }
diff --git a/src/views/dyn_stack.rs b/src/views/dyn_stack.rs
index 7544d440..409b7023 100644
--- a/src/views/dyn_stack.rs
+++ b/src/views/dyn_stack.rs
@@ -10,7 +10,7 @@ use smallvec::SmallVec;
 use crate::{
     context::{AppState, UpdateCx},
     id::Id,
-    view::{view_children_set_parent_id, View, ViewData},
+    view::{view_children_set_parent_id, AnyWidget, View, ViewData, Widget},
 };
 
 pub(crate) type FxIndexSet<T> = indexmap::IndexSet<T, BuildHasherDefault<FxHasher>>;
@@ -19,18 +19,17 @@ pub(crate) type FxIndexSet<T> = indexmap::IndexSet<T, BuildHasherDefault<FxHashe
 #[educe(Debug)]
 pub(crate) struct HashRun<T>(#[educe(Debug(ignore))] pub(crate) T);
 
-pub struct DynStack<V, T>
+pub struct DynStack<T>
 where
-    V: View,
     T: 'static,
 {
     data: ViewData,
-    children: Vec<Option<(V, Scope)>>,
-    view_fn: Box<dyn Fn(T) -> (V, Scope)>,
+    children: Vec<Option<(AnyWidget, Scope)>>,
+    view_fn: Box<dyn Fn(T) -> (AnyWidget, Scope)>,
     phantom: PhantomData<T>,
 }
 
-pub fn dyn_stack<IF, I, T, KF, K, VF, V>(each_fn: IF, key_fn: KF, view_fn: VF) -> DynStack<V, T>
+pub fn dyn_stack<IF, I, T, KF, K, VF, V>(each_fn: IF, key_fn: KF, view_fn: VF) -> DynStack<T>
 where
     IF: Fn() -> I + 'static,
     I: IntoIterator<Item = T>,
@@ -68,7 +67,7 @@ where
         id.update_state(diff);
         HashRun(hashed_items)
     });
-    let view_fn = Box::new(as_child_of_current_scope(view_fn));
+    let view_fn = Box::new(as_child_of_current_scope(move |e| view_fn(e).build()));
     DynStack {
         data: ViewData::new(id),
         children: Vec::new(),
@@ -77,7 +76,7 @@ where
     }
 }
 
-impl<V: View + 'static, T> View for DynStack<V, T> {
+impl<T> View for DynStack<T> {
     fn view_data(&self) -> &ViewData {
         &self.data
     }
@@ -86,7 +85,21 @@ impl<V: View + 'static, T> View for DynStack<V, T> {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl<T> Widget for DynStack<T> {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for child in self.children.iter().filter_map(|child| child.as_ref()) {
             if for_each(&child.0) {
                 break;
@@ -94,7 +107,7 @@ impl<V: View + 'static, T> View for DynStack<V, T> {
         }
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for child in self.children.iter_mut().filter_map(|child| child.as_mut()) {
             if for_each(&mut child.0) {
                 break;
@@ -104,7 +117,7 @@ impl<V: View + 'static, T> View for DynStack<V, T> {
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for child in self
             .children
@@ -261,7 +274,7 @@ pub(crate) fn diff<K: Eq + Hash, V>(from: &FxIndexSet<K>, to: &FxIndexSet<K>) ->
     diffs
 }
 
-fn remove_index<V: View>(
+fn remove_index<V: Widget>(
     app_state: &mut AppState,
     children: &mut [Option<(V, Scope)>],
     index: usize,
@@ -279,7 +292,7 @@ pub(super) fn apply_diff<T, V, VF>(
     children: &mut Vec<Option<(V, Scope)>>,
     view_fn: &VF,
 ) where
-    V: View,
+    V: Widget,
     VF: Fn(T) -> (V, Scope),
 {
     // Resize children if needed
@@ -319,7 +332,7 @@ pub(super) fn apply_diff<T, V, VF>(
     for DiffOpAdd { at, view } in diff.added {
         children[at] = view.map(view_fn);
         if let Some((child, _)) = children[at].as_ref() {
-            child.id().set_parent(view_id);
+            child.view_data().id().set_parent(view_id);
             view_children_set_parent_id(child);
         }
     }
diff --git a/src/views/empty.rs b/src/views/empty.rs
index e16ee7e3..3a5798a9 100644
--- a/src/views/empty.rs
+++ b/src/views/empty.rs
@@ -1,6 +1,6 @@
 use crate::{
     id::Id,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
 };
 
 pub struct Empty {
@@ -21,4 +21,18 @@ impl View for Empty {
     fn view_data_mut(&mut self) -> &mut ViewData {
         &mut self.data
     }
+
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for Empty {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
 }
diff --git a/src/views/img.rs b/src/views/img.rs
index fc5b109c..a237eba9 100644
--- a/src/views/img.rs
+++ b/src/views/img.rs
@@ -9,7 +9,7 @@ use crate::{
     id::Id,
     style::Style,
     unit::UnitExt,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
 };
 
 use taffy::prelude::Node;
@@ -121,6 +121,20 @@ impl View for Img {
         &mut self.data
     }
 
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for Img {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "Img".into()
     }
diff --git a/src/views/label.rs b/src/views/label.rs
index 4b03c947..a9e94b67 100644
--- a/src/views/label.rs
+++ b/src/views/label.rs
@@ -8,7 +8,7 @@ use crate::{
     style::Style,
     style::{FontProps, LineHeight, TextColor, TextOverflow, TextOverflowProp},
     unit::PxPct,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
 };
 use floem_peniko::Color;
 use floem_reactive::create_updater;
@@ -132,6 +132,20 @@ impl View for Label {
         &mut self.data
     }
 
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for Label {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         format!("Label: {:?}", self.label).into()
     }
diff --git a/src/views/list.rs b/src/views/list.rs
index 52af8eea..72c468a2 100644
--- a/src/views/list.rs
+++ b/src/views/list.rs
@@ -2,12 +2,13 @@ use super::{v_stack_from_iter, Decorators, Stack};
 use crate::context::StyleCx;
 use crate::reactive::create_effect;
 use crate::style::Style;
+use crate::view::View;
 use crate::EventPropagation;
 use crate::{
     event::{Event, EventListener},
     id::Id,
     keyboard::{Key, NamedKey},
-    view::{View, ViewData},
+    view::{ViewData, Widget},
 };
 use floem_reactive::{create_rw_signal, RwSignal};
 
@@ -20,7 +21,7 @@ pub(crate) struct Item {
     pub(crate) data: ViewData,
     pub(crate) index: usize,
     pub(crate) selection: RwSignal<Option<usize>>,
-    pub(crate) child: Box<dyn View>,
+    pub(crate) child: Box<dyn Widget>,
 }
 
 pub struct List {
@@ -45,7 +46,7 @@ impl List {
 
 pub fn list<V>(iterator: impl IntoIterator<Item = V>) -> List
 where
-    V: View + 'static,
+    V: Widget + 'static,
 {
     let id = Id::next();
     let selection = create_rw_signal(None);
@@ -144,17 +145,31 @@ impl View for List {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for List {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
@@ -171,7 +186,7 @@ impl View for List {
                 }
                 ListUpdate::ScrollToSelected => {
                     if let Some(index) = self.selection.get_untracked() {
-                        self.child.children[index].id().scroll_to(None);
+                        self.child.children[index].view_data().id().scroll_to(None);
                     }
                 }
             }
@@ -188,21 +203,35 @@ impl View for Item {
         &mut self.data
     }
 
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for Item {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
     fn view_style(&self) -> Option<crate::style::Style> {
         Some(Style::new().flex_col())
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
diff --git a/src/views/rich_text.rs b/src/views/rich_text.rs
index 09578e69..13c03caa 100644
--- a/src/views/rich_text.rs
+++ b/src/views/rich_text.rs
@@ -10,7 +10,7 @@ use crate::{
     id::Id,
     style::{Style, TextOverflow},
     unit::PxPct,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
 };
 
 pub struct RichText {
@@ -46,6 +46,20 @@ impl View for RichText {
         &mut self.data
     }
 
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for RichText {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         format!(
             "RichText: {:?}",
diff --git a/src/views/scroll.rs b/src/views/scroll.rs
index 425d93d2..933893ef 100644
--- a/src/views/scroll.rs
+++ b/src/views/scroll.rs
@@ -11,7 +11,7 @@ use crate::{
     style::{Background, BorderColor, BorderRadius, Style, StyleSelector},
     style_class,
     unit::Px,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
     EventPropagation,
 };
 
@@ -65,7 +65,7 @@ const HANDLE_COLOR: Color = Color::rgba8(0, 0, 0, 120);
 
 pub struct Scroll {
     data: ViewData,
-    child: Box<dyn View>,
+    child: Box<dyn Widget>,
 
     /// the actual rect of the scroll view excluding padding and borders. The origin is relative to this view.
     actual_rect: Rect,
@@ -99,7 +99,7 @@ pub struct Scroll {
 pub fn scroll<V: View + 'static>(child: V) -> Scroll {
     Scroll {
         data: ViewData::new(Id::next()),
-        child: Box::new(child),
+        child: child.build(),
         actual_rect: Rect::ZERO,
         child_size: Size::ZERO,
         child_viewport: Rect::ZERO,
@@ -304,7 +304,7 @@ impl Scroll {
         child_viewport = child_viewport.with_size(actual_size);
 
         if child_viewport != self.child_viewport {
-            app_state.set_viewport(self.child.id(), child_viewport);
+            app_state.set_viewport(self.child.view_data().id(), child_viewport);
             app_state.request_compute_layout_recursive(self.id());
             app_state.request_paint(self.id());
             self.child_viewport = child_viewport;
@@ -317,7 +317,7 @@ impl Scroll {
 
     fn child_size(&self, app_state: &mut AppState) -> Size {
         app_state
-            .get_layout(self.child.id())
+            .get_layout(self.child.view_data().id())
             .map(|layout| Size::new(layout.size.width as f64, layout.size.height as f64))
             .unwrap()
     }
@@ -625,17 +625,31 @@ impl View for Scroll {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for Scroll {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
diff --git a/src/views/stack.rs b/src/views/stack.rs
index f22273b2..0cff9e9d 100644
--- a/src/views/stack.rs
+++ b/src/views/stack.rs
@@ -4,20 +4,20 @@ use crate::{
     context::UpdateCx,
     id::Id,
     style::Style,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
     view_tuple::ViewTuple,
 };
 
 pub struct Stack {
     data: ViewData,
-    pub(crate) children: Vec<Box<dyn View>>,
+    pub(crate) children: Vec<Box<dyn Widget>>,
     direction: Option<FlexDirection>,
 }
 
 pub fn stack<VT: ViewTuple + 'static>(children: VT) -> Stack {
     Stack {
         data: ViewData::new(Id::next()),
-        children: children.into_views(),
+        children: children.into_widgets(),
         direction: None,
     }
 }
@@ -26,7 +26,7 @@ pub fn stack<VT: ViewTuple + 'static>(children: VT) -> Stack {
 pub fn h_stack<VT: ViewTuple + 'static>(children: VT) -> Stack {
     Stack {
         data: ViewData::new(Id::next()),
-        children: children.into_views(),
+        children: children.into_widgets(),
         direction: Some(FlexDirection::Row),
     }
 }
@@ -35,7 +35,7 @@ pub fn h_stack<VT: ViewTuple + 'static>(children: VT) -> Stack {
 pub fn v_stack<VT: ViewTuple + 'static>(children: VT) -> Stack {
     Stack {
         data: ViewData::new(Id::next()),
-        children: children.into_views(),
+        children: children.into_widgets(),
         direction: Some(FlexDirection::Column),
     }
 }
@@ -48,7 +48,7 @@ where
         data: ViewData::new(Id::next()),
         children: iterator
             .into_iter()
-            .map(|v| -> Box<dyn View> { Box::new(v) })
+            .map(|v| -> Box<dyn Widget> { v.build() })
             .collect(),
         direction,
     }
@@ -87,12 +87,26 @@ impl View for Stack {
         &mut self.data
     }
 
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for Stack {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
     fn view_style(&self) -> Option<crate::style::Style> {
         self.direction
             .map(|direction| Style::new().flex_direction(direction))
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for child in &self.children {
             if for_each(child) {
                 break;
@@ -100,7 +114,7 @@ impl View for Stack {
         }
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for child in &mut self.children {
             if for_each(child) {
                 break;
@@ -110,7 +124,7 @@ impl View for Stack {
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for child in self.children.iter_mut().rev() {
             if for_each(child) {
diff --git a/src/views/svg.rs b/src/views/svg.rs
index 5be9550b..308eeebd 100644
--- a/src/views/svg.rs
+++ b/src/views/svg.rs
@@ -9,7 +9,7 @@ use sha2::{Digest, Sha256};
 
 use crate::{
     id::Id,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
 };
 
 pub struct Svg {
@@ -40,6 +40,20 @@ impl View for Svg {
         &mut self.data
     }
 
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for Svg {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         "Svg".into()
     }
diff --git a/src/views/tab.rs b/src/views/tab.rs
index 03b252ed..2ba5c091 100644
--- a/src/views/tab.rs
+++ b/src/views/tab.rs
@@ -8,7 +8,7 @@ use crate::{
     context::{StyleCx, UpdateCx},
     id::Id,
     style::DisplayProp,
-    view::{View, ViewData},
+    view::{AnyWidget, View, ViewData, Widget},
 };
 
 use super::{apply_diff, diff, Diff, DiffOpAdd, FxIndexSet, HashRun};
@@ -18,15 +18,14 @@ enum TabState<V> {
     Active(usize),
 }
 
-pub struct Tab<V, T>
+pub struct Tab<T>
 where
-    V: View,
     T: 'static,
 {
     data: ViewData,
     active: usize,
-    children: Vec<Option<(V, Scope)>>,
-    view_fn: Box<dyn Fn(T) -> (V, Scope)>,
+    children: Vec<Option<(AnyWidget, Scope)>>,
+    view_fn: Box<dyn Fn(T) -> (AnyWidget, Scope)>,
     phatom: PhantomData<T>,
 }
 
@@ -35,7 +34,7 @@ pub fn tab<IF, I, T, KF, K, VF, V>(
     each_fn: IF,
     key_fn: KF,
     view_fn: VF,
-) -> Tab<V, T>
+) -> Tab<T>
 where
     IF: Fn() -> I + 'static,
     I: IntoIterator<Item = T>,
@@ -80,7 +79,7 @@ where
         id.update_state(TabState::Active::<T>(active));
     });
 
-    let view_fn = Box::new(as_child_of_current_scope(view_fn));
+    let view_fn = Box::new(as_child_of_current_scope(move |e| view_fn(e).build()));
 
     Tab {
         data: ViewData::new(id),
@@ -91,7 +90,7 @@ where
     }
 }
 
-impl<V: View + 'static, T> View for Tab<V, T> {
+impl<T> View for Tab<T> {
     fn view_data(&self) -> &ViewData {
         &self.data
     }
@@ -100,7 +99,21 @@ impl<V: View + 'static, T> View for Tab<V, T> {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl<T> Widget for Tab<T> {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for child in self.children.iter().filter_map(|child| child.as_ref()) {
             if for_each(&child.0) {
                 break;
@@ -108,7 +121,7 @@ impl<V: View + 'static, T> View for Tab<V, T> {
         }
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for child in self.children.iter_mut().filter_map(|child| child.as_mut()) {
             if for_each(&mut child.0) {
                 break;
@@ -118,7 +131,7 @@ impl<V: View + 'static, T> View for Tab<V, T> {
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for child in self
             .children
@@ -154,7 +167,7 @@ impl<V: View + 'static, T> View for Tab<V, T> {
             }
             cx.request_all(self.id());
             for (child, _) in self.children.iter().flatten() {
-                cx.request_all(child.id());
+                cx.request_all(child.view_data().id());
             }
         }
     }
@@ -167,7 +180,7 @@ impl<V: View + 'static, T> View for Tab<V, T> {
             .filter_map(|(i, child)| child.as_mut().map(|child| (i, &mut child.0)))
         {
             cx.style_view(child);
-            let child_view = cx.app_state_mut().view_state(child.id());
+            let child_view = cx.app_state_mut().view_state(child.view_data().id());
             child_view.combined_style = child_view.combined_style.clone().set(
                 DisplayProp,
                 if i != self.active {
diff --git a/src/views/text_input.rs b/src/views/text_input.rs
index bb2f1099..d478cc30 100644
--- a/src/views/text_input.rs
+++ b/src/views/text_input.rs
@@ -6,7 +6,7 @@ use crate::reactive::{create_effect, RwSignal};
 use crate::style::{CursorColor, FontProps, PaddingLeft};
 use crate::style::{FontStyle, FontWeight, TextColor};
 use crate::unit::{PxPct, PxPctAuto};
-use crate::view::ViewData;
+use crate::view::{View, ViewData};
 use crate::widgets::PlaceholderTextClass;
 use crate::{prop, prop_extracter, Clipboard, EventPropagation};
 use floem_reactive::create_rw_signal;
@@ -16,7 +16,7 @@ use floem_renderer::{cosmic_text::Cursor, Renderer};
 use floem_winit::keyboard::{Key, ModifiersState, NamedKey, SmolStr};
 use unicode_segmentation::UnicodeSegmentation;
 
-use crate::{peniko::Color, style::Style, view::View};
+use crate::{peniko::Color, style::Style, view::Widget};
 
 use std::{
     any::Any,
@@ -937,6 +937,20 @@ impl View for TextInput {
         &mut self.data
     }
 
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for TextInput {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
     fn debug_name(&self) -> std::borrow::Cow<'static, str> {
         format!("TextInput: {:?}", self.buffer.get_untracked()).into()
     }
diff --git a/src/views/tooltip.rs b/src/views/tooltip.rs
index e09dc5b1..4c5fd913 100644
--- a/src/views/tooltip.rs
+++ b/src/views/tooltip.rs
@@ -7,7 +7,7 @@ use crate::{
     event::Event,
     id::Id,
     prop, prop_extracter,
-    view::{default_compute_layout, default_event, View, ViewData},
+    view::{default_compute_layout, default_event, View, ViewData, Widget},
     EventPropagation,
 };
 
@@ -24,20 +24,20 @@ pub struct Tooltip {
     data: ViewData,
     hover: Option<(Point, TimerToken)>,
     overlay: Option<Id>,
-    child: Box<dyn View>,
-    tip: Rc<dyn Fn() -> Box<dyn View>>,
+    child: Box<dyn Widget>,
+    tip: Rc<dyn Fn() -> Box<dyn Widget>>,
     style: TooltipStyle,
     window_origin: Option<Point>,
 }
 
 /// A view that displays a tooltip for its child.
-pub fn tooltip<V: View + 'static, T: View + 'static>(
+pub fn tooltip<V: View + 'static, T: Widget + 'static>(
     child: V,
     tip: impl Fn() -> T + 'static,
 ) -> Tooltip {
     Tooltip {
         data: ViewData::new(Id::next()),
-        child: Box::new(child),
+        child: child.build(),
         tip: Rc::new(move || Box::new(tip())),
         hover: None,
         overlay: None,
@@ -55,17 +55,31 @@ impl View for Tooltip {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for Tooltip {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
diff --git a/src/views/value_container.rs b/src/views/value_container.rs
index 2ab0b526..11f570e4 100644
--- a/src/views/value_container.rs
+++ b/src/views/value_container.rs
@@ -5,13 +5,13 @@ use floem_reactive::{create_effect, create_rw_signal, create_updater, RwSignal};
 use crate::{
     context::UpdateCx,
     id::Id,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
 };
 
 /// A wrapper around another View that has value updates. See [`value_container`]
 pub struct ValueContainer<T> {
     data: ViewData,
-    child: Box<dyn View>,
+    child: Box<dyn Widget>,
     on_update: Option<Box<dyn Fn(T)>>,
 }
 
@@ -56,7 +56,7 @@ pub fn value_container<T: 'static, V: View + 'static>(
     create_updater(value_update, move |new_value| id.update_state(new_value));
     ValueContainer {
         data: ViewData::new(id),
-        child: Box::new(child),
+        child: child.build(),
         on_update: None,
     }
 }
@@ -77,6 +77,20 @@ impl<T: 'static> View for ValueContainer<T> {
         &mut self.data
     }
 
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl<T: 'static> Widget for ValueContainer<T> {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
     fn update(&mut self, _cx: &mut UpdateCx, state: Box<dyn Any>) {
         if let Ok(state) = state.downcast::<T>() {
             if let Some(on_update) = self.on_update.as_ref() {
@@ -85,17 +99,17 @@ impl<T: 'static> View for ValueContainer<T> {
         }
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
diff --git a/src/views/virtual_list.rs b/src/views/virtual_list.rs
index 3f00cb39..9be2fc1a 100644
--- a/src/views/virtual_list.rs
+++ b/src/views/virtual_list.rs
@@ -3,12 +3,13 @@ use super::{
 };
 use crate::context::ComputeLayoutCx;
 use crate::reactive::create_effect;
+use crate::view::View;
 use crate::EventPropagation;
 use crate::{
     event::{Event, EventListener},
     id::Id,
     keyboard::{Key, NamedKey},
-    view::{View, ViewData},
+    view::{ViewData, Widget},
 };
 use floem_reactive::{create_rw_signal, RwSignal};
 use kurbo::{Rect, Size};
@@ -26,7 +27,7 @@ pub struct VirtualList<T: 'static> {
     child_size: Size,
     selection: RwSignal<Option<usize>>,
     offsets: RwSignal<Vec<f64>>,
-    child: VirtualStack<Item, (usize, T)>,
+    child: VirtualStack<(usize, T)>,
 }
 
 impl<T> VirtualList<T> {
@@ -57,7 +58,7 @@ where
     KF: Fn(&T) -> K + 'static,
     K: Eq + Hash + 'static,
     VF: Fn(T) -> V + 'static,
-    V: View + 'static,
+    V: Widget + 'static,
 {
     let id = Id::next();
     let selection = create_rw_signal(None);
@@ -218,17 +219,31 @@ impl<T> View for VirtualList<T> {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl<T> Widget for VirtualList<T> {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
diff --git a/src/views/virtual_stack.rs b/src/views/virtual_stack.rs
index b6eb9a9c..9964d3a5 100644
--- a/src/views/virtual_stack.rs
+++ b/src/views/virtual_stack.rs
@@ -12,7 +12,7 @@ use crate::{
     context::ComputeLayoutCx,
     id::Id,
     unit::PxPct,
-    view::{self, View, ViewData},
+    view::{self, AnyWidget, View, ViewData, Widget},
 };
 
 use super::{apply_diff, diff, Diff, DiffOpAdd, FxIndexSet, HashRun};
@@ -48,16 +48,16 @@ pub trait VirtualVector<T> {
     }
 }
 
-pub struct VirtualStack<V: View, T>
+pub struct VirtualStack<T>
 where
     T: 'static,
 {
     data: ViewData,
     direction: VirtualDirection,
-    children: Vec<Option<(V, Scope)>>,
+    children: Vec<Option<(AnyWidget, Scope)>>,
     viewport: Rect,
     set_viewport: WriteSignal<Rect>,
-    view_fn: Box<dyn Fn(T) -> (V, Scope)>,
+    view_fn: Box<dyn Fn(T) -> (AnyWidget, Scope)>,
     phatom: PhantomData<T>,
     before_size: f64,
     content_size: f64,
@@ -77,7 +77,7 @@ pub fn virtual_stack<T, IF, I, KF, K, VF, V>(
     each_fn: IF,
     key_fn: KF,
     view_fn: VF,
-) -> VirtualStack<V, T>
+) -> VirtualStack<T>
 where
     T: 'static,
     IF: Fn() -> I + 'static,
@@ -182,7 +182,7 @@ where
         (before_size, content_size, HashRun(hashed_items))
     });
 
-    let view_fn = Box::new(as_child_of_current_scope(view_fn));
+    let view_fn = Box::new(as_child_of_current_scope(move |e| view_fn(e).build()));
 
     VirtualStack {
         data: ViewData::new(id),
@@ -199,7 +199,7 @@ where
     }
 }
 
-impl<V: View + 'static, T> View for VirtualStack<V, T> {
+impl<T> View for VirtualStack<T> {
     fn view_data(&self) -> &ViewData {
         &self.data
     }
@@ -208,7 +208,21 @@ impl<V: View + 'static, T> View for VirtualStack<V, T> {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl<T> Widget for VirtualStack<T> {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for child in self.children.iter().filter_map(|child| child.as_ref()) {
             if for_each(&child.0) {
                 break;
@@ -216,7 +230,7 @@ impl<V: View + 'static, T> View for VirtualStack<V, T> {
         }
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for child in self.children.iter_mut().filter_map(|child| child.as_mut()) {
             if for_each(&mut child.0) {
                 break;
@@ -226,7 +240,7 @@ impl<V: View + 'static, T> View for VirtualStack<V, T> {
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for child in self
             .children
diff --git a/src/widgets/slider.rs b/src/widgets/slider.rs
index 4be7ac47..40a3f7a7 100644
--- a/src/widgets/slider.rs
+++ b/src/widgets/slider.rs
@@ -11,7 +11,7 @@ use crate::{
     style::{Background, BorderRadius, Foreground, Height},
     style_class,
     unit::{PxPct, PxPctAuto},
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
     views::Decorators,
     EventPropagation,
 };
@@ -144,6 +144,20 @@ impl View for Slider {
         &mut self.data
     }
 
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for Slider {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
     fn update(&mut self, cx: &mut crate::context::UpdateCx, state: Box<dyn std::any::Any>) {
         if let Ok(update) = state.downcast::<SliderUpdate>() {
             match *update {
diff --git a/src/widgets/toggle_button.rs b/src/widgets/toggle_button.rs
index 7286cbf9..f17e789d 100644
--- a/src/widgets/toggle_button.rs
+++ b/src/widgets/toggle_button.rs
@@ -10,7 +10,7 @@ use crate::{
     style::{self, Foreground},
     style_class,
     unit::PxPct,
-    view::{View, ViewData},
+    view::{View, ViewData, Widget},
     views::Decorators,
     EventPropagation,
 };
@@ -108,6 +108,20 @@ impl View for ToggleButton {
         &mut self.data
     }
 
+    fn build(self) -> Box<dyn Widget> {
+        Box::new(self)
+    }
+}
+
+impl Widget for ToggleButton {
+    fn view_data(&self) -> &ViewData {
+        &self.data
+    }
+
+    fn view_data_mut(&mut self) -> &mut ViewData {
+        &mut self.data
+    }
+
     fn update(&mut self, cx: &mut crate::context::UpdateCx, state: Box<dyn std::any::Any>) {
         if let Ok(state) = state.downcast::<bool>() {
             if self.held == ToggleState::Nothing {
diff --git a/src/window.rs b/src/window.rs
index c16788a2..fbdae3dc 100644
--- a/src/window.rs
+++ b/src/window.rs
@@ -6,10 +6,8 @@ pub use floem_winit::window::WindowId;
 pub use floem_winit::window::WindowLevel;
 use kurbo::{Point, Size};
 
-use crate::{
-    app::{add_app_update_event, AppUpdateEvent},
-    view::View,
-};
+use crate::app::{add_app_update_event, AppUpdateEvent};
+use crate::view::View;
 
 #[derive(Default, Debug)]
 pub struct WindowConfig {
@@ -93,7 +91,7 @@ pub fn new_window<V: View + 'static>(
     config: Option<WindowConfig>,
 ) {
     add_app_update_event(AppUpdateEvent::NewWindow {
-        view_fn: Box::new(|window_id| Box::new(app_view(window_id))),
+        view_fn: Box::new(|window_id| app_view(window_id).any()),
         config,
     });
 }
diff --git a/src/window_handle.rs b/src/window_handle.rs
index eb2f1e88..e4c1aa92 100644
--- a/src/window_handle.rs
+++ b/src/window_handle.rs
@@ -40,7 +40,7 @@ use crate::{
         CENTRAL_UPDATE_MESSAGES, CURRENT_RUNNING_VIEW_HANDLE, DEFERRED_UPDATE_MESSAGES,
         UPDATE_MESSAGES,
     },
-    view::{view_children_set_parent_id, view_tab_navigation, View, ViewData},
+    view::{view_children_set_parent_id, view_tab_navigation, AnyView, View, ViewData, Widget},
     view_data::{update_data, ChangeFlags},
     widgets::{default_theme, Theme},
 };
@@ -78,7 +78,7 @@ pub(crate) struct WindowHandle {
 impl WindowHandle {
     pub(crate) fn new(
         window: floem_winit::window::Window,
-        view_fn: impl FnOnce(floem_winit::window::WindowId) -> Box<dyn View> + 'static,
+        view_fn: impl FnOnce(floem_winit::window::WindowId) -> AnyView + 'static,
         transparent: bool,
         apply_default_theme: bool,
     ) -> Self {
@@ -106,21 +106,22 @@ impl WindowHandle {
 
         #[cfg(target_os = "linux")]
         let view = with_scope(scope, move || {
-            Box::new(
-                stack((
-                    container_box(view_fn(window_id)).style(|s| s.size(100.pct(), 100.pct())),
-                    context_menu_view(scope, window_id, context_menu, size),
-                ))
-                .style(|s| s.size(100.pct(), 100.pct())),
-            )
+            stack((
+                container_box(view_fn(window_id)).style(|s| s.size(100.pct(), 100.pct())),
+                context_menu_view(scope, window_id, context_menu, size),
+            ))
+            .style(|s| s.size(100.pct(), 100.pct()))
+            .any()
         });
 
-        view.id().set_parent(id);
-        view_children_set_parent_id(&*view);
+        let widget = view.build();
+
+        widget.view_data().id().set_parent(id);
+        view_children_set_parent_id(&*widget);
 
         let view = WindowView {
             data: ViewData::new(id),
-            main: view,
+            main: widget,
             overlays: Default::default(),
         };
 
@@ -206,7 +207,8 @@ impl WindowHandle {
                     }
 
                     if let Some(listener) = event.listener() {
-                        if let Some(action) = cx.get_event_listener(self.view.main.id(), &listener)
+                        if let Some(action) =
+                            cx.get_event_listener(self.view.main.view_data().id(), &listener)
                         {
                             processed |= (*action)(&event).is_processed();
                         }
@@ -496,9 +498,9 @@ impl WindowHandle {
     }
 
     fn style(&mut self) {
-        let mut cx = StyleCx::new(&mut self.app_state, self.view.id());
-        if let Some(style) = self.theme.as_ref().map(|theme| theme.style.clone()) {
-            cx.current = style;
+        let mut cx = StyleCx::new(&mut self.app_state, self.view.view_data().id());
+        if let Some(theme) = &self.theme {
+            cx.current = theme.style.clone();
         }
         cx.style_view(&mut self.view);
     }
@@ -588,7 +590,7 @@ impl WindowHandle {
     pub(crate) fn capture(&mut self) -> Capture {
         // Capture the view before we run `style` and `layout` to catch missing `request_style`` or
         // `request_layout` flags.
-        let root_layout = self.app_state.get_layout_rect(self.view.id());
+        let root_layout = self.app_state.get_layout_rect(self.view.view_data().id());
         let root = CapturedView::capture(&self.view, &mut self.app_state, root_layout);
 
         self.app_state.capture = Some(CaptureState::default());
@@ -621,7 +623,7 @@ impl WindowHandle {
         self.style();
         let post_style = Instant::now();
 
-        let taffy_root_node = self.app_state.view_state(self.view.id()).node;
+        let taffy_root_node = self.app_state.view_state(self.view.view_data().id()).node;
         let taffy_duration = self.layout();
         let post_layout = Instant::now();
         let window = self.paint().map(Rc::new);
@@ -901,7 +903,7 @@ impl WindowHandle {
                     }
                     UpdateMessage::WindowScale(scale) => {
                         cx.app_state.scale = scale;
-                        cx.request_layout(self.view.id());
+                        cx.request_layout(self.view.view_data().id());
                         let scale = self.scale * cx.app_state.scale;
                         self.paint_state.set_scale(scale);
                     }
@@ -973,7 +975,7 @@ impl WindowHandle {
                             child: view,
                         };
 
-                        view.id().set_parent(self.id);
+                        view.view_data().id().set_parent(self.id);
                         view_children_set_parent_id(&view);
 
                         self.view.overlays.insert(id, view);
@@ -1075,14 +1077,14 @@ impl WindowHandle {
 
     fn needs_layout(&mut self) -> bool {
         self.app_state
-            .view_state(self.view.id())
+            .view_state(self.view.view_data().id())
             .requested_changes
             .contains(ChangeFlags::LAYOUT)
     }
 
     fn needs_style(&mut self) -> bool {
         self.app_state
-            .view_state(self.view.id())
+            .view_state(self.view.view_data().id())
             .requested_changes
             .contains(ChangeFlags::STYLE)
     }
@@ -1524,10 +1526,10 @@ struct OverlayView {
     data: ViewData,
     scope: Scope,
     position: Point,
-    child: Box<dyn View>,
+    child: Box<dyn Widget>,
 }
 
-impl View for OverlayView {
+impl Widget for OverlayView {
     fn view_data(&self) -> &ViewData {
         &self.data
     }
@@ -1545,17 +1547,17 @@ impl View for OverlayView {
         )
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.child);
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.child);
     }
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for_each(&mut self.child);
     }
@@ -1568,11 +1570,11 @@ impl View for OverlayView {
 /// A view representing a window which manages the main window view and any overlays.
 struct WindowView {
     data: ViewData,
-    main: Box<dyn View>,
+    main: Box<dyn Widget>,
     overlays: IndexMap<Id, OverlayView>,
 }
 
-impl View for WindowView {
+impl Widget for WindowView {
     fn view_data(&self) -> &ViewData {
         &self.data
     }
@@ -1585,14 +1587,14 @@ impl View for WindowView {
         &mut self.data
     }
 
-    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn View) -> bool) {
+    fn for_each_child<'a>(&'a self, for_each: &mut dyn FnMut(&'a dyn Widget) -> bool) {
         for_each(&self.main);
         for overlay in self.overlays.values() {
             for_each(overlay);
         }
     }
 
-    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn View) -> bool) {
+    fn for_each_child_mut<'a>(&'a mut self, for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool) {
         for_each(&mut self.main);
         for overlay in self.overlays.values_mut() {
             for_each(overlay);
@@ -1601,7 +1603,7 @@ impl View for WindowView {
 
     fn for_each_child_rev_mut<'a>(
         &'a mut self,
-        for_each: &mut dyn FnMut(&'a mut dyn View) -> bool,
+        for_each: &mut dyn FnMut(&'a mut dyn Widget) -> bool,
     ) {
         for overlay in self.overlays.values_mut().rev() {
             for_each(overlay);