lol bounds

griefed last commit
app event stuff bruh
2026-01-05 17:50:18 -05:00 · 2026-01-05 17:20:11 -05:00 · 2026-01-05 17:16:56 -05:00 · 2026-01-05 17:01:09 -05:00 · 2026-01-04 14:45:18 -05:00 · 2026-01-03 18:06:05 -05:00
34 changed files with 1089 additions and 933 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,5 @@
 [package]
 name = "iris"
-default-run = "test"
 version.workspace = true
 edition.workspace = true

@@ -16,6 +15,10 @@ arboard = { workspace = true, features = ["wayland-data-control"] }
 pollster = { workspace = true }
 wgpu = { workspace = true }
 image = { workspace = true }
+tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread"] }
+
+[dev-dependencies]
+tokio = { workspace = true, features = ["sync", "rt", "rt-multi-thread", "time"] }

 [workspace]
 members = ["core", "macro"]
@@ -27,12 +30,13 @@ edition = "2024"
 [workspace.dependencies]
 pollster = "0.4.0"
 winit = "0.30.12"
-wgpu = "27.0.1"
+wgpu = "28.0.0"
 bytemuck = "1.23.1"
 image = "0.25.6"
-cosmic-text = "0.15.0"
+cosmic-text = "0.16.0"
 unicode-segmentation = "1.12.0"
 fxhash = "0.2.1"
 arboard = "3.6.1"
 iris-core = { path = "core" }
 iris-macro = { path = "macro" }
+tokio = "1.49.0"
--- a/core/src/attr.rs
+++ b/core/src/attr.rs
@@ -1,24 +1,22 @@
-use crate::{HasUi, StateLike, WidgetIdFn, WidgetLike, WidgetRef};
+use crate::{HasUi, WidgetIdFn, WidgetLike, WidgetRef};

-pub trait WidgetAttr<State, W: ?Sized> {
+pub trait WidgetAttr<Rsc, W: ?Sized> {
    type Input;
-    fn run(state: &mut State, id: WidgetRef<W>, input: Self::Input);
+    fn run(rsc: &mut Rsc, id: WidgetRef<W>, input: Self::Input);
 }

-pub trait Attrable<State, W: ?Sized, Tag> {
-    fn attr<A: WidgetAttr<State, W>>(self, input: A::Input) -> impl WidgetIdFn<State, W>;
+pub trait Attrable<Rsc, W: ?Sized, Tag> {
+    fn attr<A: WidgetAttr<Rsc, W>>(self, input: A::Input) -> impl WidgetIdFn<Rsc, W>;
 }

-impl<State: HasUi + StateLike<State>, WL: WidgetLike<State, Tag>, Tag>
-    Attrable<State, WL::Widget, Tag> for WL
-{
-    fn attr<A: WidgetAttr<State, WL::Widget>>(
+impl<Rsc: HasUi, WL: WidgetLike<Rsc, Tag>, Tag> Attrable<Rsc, WL::Widget, Tag> for WL {
+    fn attr<A: WidgetAttr<Rsc, WL::Widget>>(
        self,
        input: A::Input,
-    ) -> impl WidgetIdFn<State, WL::Widget> {
-        |state| {
-            let id = self.add(state);
-            A::run(state, id, input);
+    ) -> impl WidgetIdFn<Rsc, WL::Widget> {
+        |rsc| {
+            let id = self.add(rsc);
+            A::run(rsc, id, input);
            id
        }
    }
--- a/core/src/event/ctx.rs
+++ b/core/src/event/ctx.rs
@@ -1,116 +1,18 @@
-use crate::{HasEvents, HasState, HasUi, StateLike, Ui, Widget, WidgetRef};
-use std::ops::{Deref, DerefMut};
+use crate::{HasEvents, HasUi, Widget, WidgetRef};

-pub struct EventCtx<'a, State, Data> {
-    pub state: &'a mut State,
-    pub data: &'a mut Data,
+pub struct EventCtx<'a, Rsc: HasEvents, Data> {
+    pub state: &'a mut Rsc::State,
+    pub data: Data,
 }

-pub struct EventIdCtx<'a, State, Data, W: ?Sized> {
+pub struct EventIdCtx<'a, Rsc: HasEvents, Data, W: ?Sized> {
    pub widget: WidgetRef<W>,
-    pub state: &'a mut State,
-    pub data: &'a mut Data,
+    pub state: &'a mut Rsc::State,
+    pub data: Data,
 }

-impl<State: HasUi, Data, W: ?Sized> Deref for EventIdCtx<'_, State, Data, W> {
-    type Target = State;
-
-    fn deref(&self) -> &Self::Target {
-        self.state
+impl<Rsc: HasEvents + HasUi, Data, W: Widget> EventIdCtx<'_, Rsc, Data, W> {
+    pub fn widget<'a>(&self, rsc: &'a mut Rsc) -> &'a mut W {
+        &mut rsc.ui_mut()[self.widget]
    }
 }
-
-impl<State: HasUi, Data, W: ?Sized> DerefMut for EventIdCtx<'_, State, Data, W> {
-    fn deref_mut(&mut self) -> &mut Self::Target {
-        self.state
-    }
-}
-
-impl<State: HasUi, Data, W: Widget> EventIdCtx<'_, State, Data, W> {
-    pub fn widget(&mut self) -> &mut W {
-        &mut self.state.get_mut()[self.widget]
-    }
-}
-
-impl<State: HasUi, Data, W: Widget> HasUi for EventIdCtx<'_, State, Data, W> {
-    fn get(&self) -> &Ui {
-        self.state.ui()
-    }
-
-    fn get_mut(&mut self) -> &mut Ui {
-        self.state.ui_mut()
-    }
-}
-
-impl<State: HasUi, Data, W: Widget> HasState for EventIdCtx<'_, State, Data, W> {
-    type State = State;
-}
-
-impl<State: HasEvents<State = State>, Data, W: Widget> HasEvents
-    for EventIdCtx<'_, State, Data, W>
-{
-    fn get(&self) -> &super::EventManager<Self::State> {
-        self.state.events()
-    }
-
-    fn get_mut(&mut self) -> &mut super::EventManager<Self::State> {
-        self.state.events_mut()
-    }
-}
-
-impl<State, Data, W: Widget> StateLike<State> for EventIdCtx<'_, State, Data, W> {
-    fn as_state(&mut self) -> &mut State {
-        self.state
-    }
-}
-
-// fn test() {
-//     use crate::*;
-//     struct ClientRsc;
-//     impl<State, Data> HasUi for EventCtx<'_, State, Data> {
-//         fn get(&self) -> &Ui {
-//             todo!()
-//         }
-//
-//         fn get_mut(&mut self) -> &mut Ui {
-//             todo!()
-//         }
-//     }
-//     fn on(_: impl for<'a> EventFn<ClientRsc, &'a mut i32>) {}
-//
-//     pub trait WidgetLike<State: HasUi, Tag>: Sized {
-//         type Widget: Widget + ?Sized + std::marker::Unsize<dyn Widget>;
-//
-//         fn add(self, state: &mut State) -> WidgetHandle<Self::Widget>;
-//
-//         fn with_id<W2>(
-//             self,
-//             f: impl FnOnce(&mut State, WidgetHandle<Self::Widget>) -> WidgetHandle<W2>,
-//         ) -> impl WidgetIdFn<State, W2> {
-//             move |state| {
-//                 let id = self.add(state);
-//                 f(state, id)
-//             }
-//         }
-//
-//         fn set_root(self, state: &mut State) {
-//             state.get_mut().root = Some(self.add(state));
-//         }
-//
-//         fn handles(self, state: &mut State) -> WidgetHandles<Self::Widget> {
-//             self.add(state).handles()
-//         }
-//     }
-//
-//     pub struct WidgetTag;
-//     impl<State: HasUi, W: Widget> WidgetLike<State, WidgetTag> for W {
-//         type Widget = W;
-//         fn add(self, state: &mut State) -> WidgetHandle<W> {
-//             state.get_mut().add_widget(self)
-//         }
-//     }
-//
-//     on(move |ctx| {
-//         ().add(ctx);
-//     });
-// }
--- a/core/src/event/manager.rs
+++ b/core/src/event/manager.rs
@@ -1,16 +1,16 @@
 use crate::{
-    ActiveData, Event, EventCtx, EventFn, EventIdCtx, EventLike, IdLike, LayerId, Widget,
-    WidgetEventFn, WidgetId, WidgetRef,
+    ActiveData, Event, EventCtx, EventFn, EventIdCtx, EventLike, HasEvents, IdLike, LayerId,
+    Widget, WidgetEventFn, WidgetId, WidgetRef,
    util::{HashMap, HashSet, TypeMap},
 };
 use std::{any::TypeId, rc::Rc};

-pub struct EventManager<State> {
+pub struct EventManager<Rsc> {
    widget_to_types: HashMap<WidgetId, HashSet<TypeId>>,
-    types: TypeMap<dyn EventManagerLike<State>>,
+    types: TypeMap<dyn EventManagerLike<Rsc>>,
 }

-impl<State> Default for EventManager<State> {
+impl<Rsc> Default for EventManager<Rsc> {
    fn default() -> Self {
        Self {
            widget_to_types: Default::default(),
@@ -19,8 +19,8 @@ impl<State> Default for EventManager<State> {
    }
 }

-impl<State: 'static> EventManager<State> {
-    pub fn get_type<E: EventLike>(&mut self) -> &mut TypeEventManager<State, E::Event> {
+impl<Rsc: HasEvents + 'static> EventManager<Rsc> {
+    pub fn get_type<E: EventLike>(&mut self) -> &mut TypeEventManager<Rsc, E::Event> {
        self.types.type_or_default()
    }

@@ -28,7 +28,7 @@ impl<State: 'static> EventManager<State> {
        &mut self,
        id: WidgetRef<W>,
        event: E,
-        f: impl for<'a> WidgetEventFn<State, <E::Event as Event>::Data<'a>, W>,
+        f: impl WidgetEventFn<Rsc, <E::Event as Event>::Data, W>,
    ) {
        self.get_type::<E>().register(id, event, f);
        self.widget_to_types
@@ -38,7 +38,7 @@ impl<State: 'static> EventManager<State> {
    }

    pub fn type_key<E: EventLike>() -> TypeId {
-        TypeId::of::<TypeEventManager<State, E::Event>>()
+        TypeId::of::<TypeEventManager<Rsc, E::Event>>()
    }
 }

@@ -48,7 +48,7 @@ pub trait EventsLike {
    fn undraw(&mut self, active: &ActiveData);
 }

-impl<State: 'static> EventsLike for EventManager<State> {
+impl<Rsc: HasEvents + 'static> EventsLike for EventManager<Rsc> {
    fn remove(&mut self, id: WidgetId) {
        for t in self.widget_to_types.get(&id).into_flat_iter() {
            self.types.get_mut(t).unwrap().remove(id);
@@ -74,14 +74,14 @@ pub trait EventManagerLike<State> {
    fn undraw(&mut self, data: &ActiveData);
 }

-type EventData<State, E> = (E, Rc<dyn for<'a> EventFn<State, <E as Event>::Data<'a>>>);
-pub struct TypeEventManager<State, E: Event> {
+type EventData<Rsc, E> = (E, Rc<dyn EventFn<Rsc, <E as Event>::Data>>);
+pub struct TypeEventManager<Rsc: HasEvents, E: Event> {
    // TODO: reduce visiblity!!
    pub active: HashMap<LayerId, HashMap<WidgetId, E::State>>,
-    map: HashMap<WidgetId, Vec<EventData<State, E>>>,
+    map: HashMap<WidgetId, Vec<EventData<Rsc, E>>>,
 }

-impl<State, E: Event> EventManagerLike<State> for TypeEventManager<State, E> {
+impl<Rsc: HasEvents, E: Event> EventManagerLike<Rsc> for TypeEventManager<Rsc, E> {
    fn remove(&mut self, id: WidgetId) {
        self.map.remove(&id);
        for layer in self.active.values_mut() {
@@ -102,7 +102,7 @@ impl<State, E: Event> EventManagerLike<State> for TypeEventManager<State, E> {
    }
 }

-impl<State, E: Event> Default for TypeEventManager<State, E> {
+impl<Rsc: HasEvents, E: Event> Default for TypeEventManager<Rsc, E> {
    fn default() -> Self {
        Self {
            active: Default::default(),
@@ -111,23 +111,25 @@ impl<State, E: Event> Default for TypeEventManager<State, E> {
    }
 }

-impl<State: 'static, E: Event> TypeEventManager<State, E> {
+impl<Rsc: HasEvents + 'static, E: Event> TypeEventManager<Rsc, E> {
    fn register<W: Widget + ?Sized>(
        &mut self,
        widget: WidgetRef<W>,
        event: impl EventLike<Event = E>,
-        f: impl for<'a> WidgetEventFn<State, E::Data<'a>, W>,
+        f: impl WidgetEventFn<Rsc, E::Data, W>,
    ) {
        let event = event.into_event();
        self.map.entry(widget.id()).or_default().push((
            event,
-            Rc::new(move |ctx| {
-                let mut test = EventIdCtx {
+            Rc::new(move |ctx, rsc| {
+                f(
+                    EventIdCtx {
                        widget,
                        state: ctx.state,
                        data: ctx.data,
-                };
-                f(&mut test);
+                    },
+                    rsc,
+                );
            }),
        ));
    }
@@ -135,15 +137,18 @@ impl<State: 'static, E: Event> TypeEventManager<State, E> {
    pub fn run_fn<'a>(
        &mut self,
        id: impl IdLike,
-    ) -> impl for<'b> FnOnce(EventCtx<'_, State, E::Data<'b>>) + 'a {
+    ) -> impl FnOnce(EventCtx<'_, Rsc, E::Data>, &mut Rsc) + 'a {
        let fs = self.map.get(&id.id()).cloned().unwrap_or_default();
-        move |ctx| {
+        move |ctx, rsc| {
            for (e, f) in fs {
-                if e.should_run(ctx.data) {
-                    f(&mut EventCtx {
+                if let Some(data) = e.should_run(&ctx.data) {
+                    f(
+                        EventCtx {
                            state: ctx.state,
-                        data: ctx.data,
-                    })
+                            data,
+                        },
+                        rsc,
+                    )
                }
            }
        }
--- a/core/src/event/mod.rs
+++ b/core/src/event/mod.rs
@@ -7,11 +7,11 @@ pub use manager::*;
 pub use rsc::*;

 pub trait Event: Sized + 'static + Clone {
-    type Data<'a> = ();
+    type Data: Clone = ();
    type State: Default = ();
    #[allow(unused_variables)]
-    fn should_run(&self, data: &mut Self::Data<'_>) -> bool {
-        true
+    fn should_run(&self, data: &Self::Data) -> Option<Self::Data> {
+        Some(data.clone())
    }
 }

@@ -28,14 +28,17 @@ impl<E: Event> EventLike for E {
    }
 }

-pub trait EventFn<State, Data>: Fn(&mut EventCtx<State, Data>) + 'static {}
-impl<State, F: Fn(&mut EventCtx<State, Data>) + 'static, Data> EventFn<State, Data> for F {}
+pub trait EventFn<Rsc: HasEvents, Data>: Fn(EventCtx<Rsc, Data>, &mut Rsc) + 'static {}
+impl<Rsc: HasEvents, F: Fn(EventCtx<Rsc, Data>, &mut Rsc) + 'static, Data> EventFn<Rsc, Data>
+    for F
+{
+}

-pub trait WidgetEventFn<State, Data, W: ?Sized>:
-    Fn(&mut EventIdCtx<State, Data, W>) + 'static
+pub trait WidgetEventFn<Rsc: HasEvents, Data, W: ?Sized>:
+    Fn(EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static
 {
 }
-impl<State, F: Fn(&mut EventIdCtx<State, Data, W>) + 'static, Data, W: ?Sized>
-    WidgetEventFn<State, Data, W> for F
+impl<Rsc: HasEvents, F: Fn(EventIdCtx<Rsc, Data, W>, &mut Rsc) + 'static, Data, W: ?Sized>
+    WidgetEventFn<Rsc, Data, W> for F
 {
 }
--- a/core/src/event/rsc.rs
+++ b/core/src/event/rsc.rs
@@ -2,40 +2,33 @@ use crate::{
    Event, EventCtx, EventLike, EventManager, HasUi, IdLike, Widget, WidgetEventFn, WidgetRef,
 };

-pub trait HasState {
-    type State: HasUi;
+pub trait HasState: 'static {
+    type State;
 }

-pub trait HasEvents: Sized + HasState + HasUi {
-    fn get(&self) -> &EventManager<Self::State>;
-    fn get_mut(&mut self) -> &mut EventManager<Self::State>;
-    fn events(&self) -> &EventManager<Self::State> {
-        HasEvents::get(self)
-    }
-    fn events_mut(&mut self) -> &mut EventManager<Self::State> {
-        HasEvents::get_mut(self)
-    }
+pub trait HasEvents: Sized + HasUi + HasState {
+    fn events(&self) -> &EventManager<Self>;
+    fn events_mut(&mut self) -> &mut EventManager<Self>;

    fn register_event<W: Widget + ?Sized, E: EventLike>(
        &mut self,
        id: WidgetRef<W>,
        event: E,
-        f: impl for<'a> WidgetEventFn<Self::State, <E::Event as Event>::Data<'a>, W>,
-    ) where
-        Self::State: 'static,
-    {
+        f: impl WidgetEventFn<Self, <E::Event as Event>::Data, W>,
+    ) {
        self.events_mut().register(id, event, f);
    }
 }

-pub trait RunEvents: HasEvents + HasState<State = Self> + 'static {
+pub trait RunEvents: HasEvents {
    fn run_event<E: EventLike>(
        &mut self,
        id: impl IdLike,
-        data: &mut <E::Event as Event>::Data<'_>,
+        data: <E::Event as Event>::Data,
+        state: &mut Self::State,
    ) {
        let f = self.events_mut().get_type::<E>().run_fn(id);
-        f(EventCtx { state: self, data })
+        f(EventCtx { state, data }, self)
    }
 }
-impl<T: HasEvents + HasState<State = Self> + 'static> RunEvents for T {}
+impl<T: HasEvents> RunEvents for T {}
--- a/core/src/render/mod.rs
+++ b/core/src/render/mod.rs
@@ -183,7 +183,7 @@ impl UiRenderNode {
        let pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
            label: Some("UI Shape Pipeline Layout"),
            bind_group_layouts: &[&uniform_layout, &primitive_layout, &rsc_layout],
-            push_constant_ranges: &[],
+            immediate_size: 0,
        });
        let pipeline = device.create_render_pipeline(&RenderPipelineDescriptor {
            label: Some("UI Shape Pipeline"),
@@ -219,7 +219,7 @@ impl UiRenderNode {
                mask: !0,
                alpha_to_coverage_enabled: false,
            },
-            multiview: None,
+            multiview_mask: None,
            cache: None,
        });

--- a/core/src/ui/mod.rs
+++ b/core/src/ui/mod.rs
@@ -42,22 +42,16 @@ pub struct Ui {
 }

 pub trait HasUi: Sized {
-    fn get(&self) -> &Ui;
-    fn get_mut(&mut self) -> &mut Ui;
-    fn ui(&self) -> &Ui {
-        self.get()
-    }
-    fn ui_mut(&mut self) -> &mut Ui {
-        self.get_mut()
-    }
+    fn ui(&self) -> &Ui;
+    fn ui_mut(&mut self) -> &mut Ui;
 }

 impl HasUi for Ui {
-    fn get(&self) -> &Ui {
+    fn ui(&self) -> &Ui {
        self
    }

-    fn get_mut(&mut self) -> &mut Ui {
+    fn ui_mut(&mut self) -> &mut Ui {
        self
    }
 }
--- a/core/src/widget/handle.rs
+++ b/core/src/widget/handle.rs
@@ -90,8 +90,8 @@ impl<W: ?Sized> Drop for WidgetHandle<W> {
    }
 }

-pub trait WidgetIdFn<State, W: ?Sized = dyn Widget>: FnOnce(&mut State) -> WidgetRef<W> {}
-impl<State, W: ?Sized, F: FnOnce(&mut State) -> WidgetRef<W>> WidgetIdFn<State, W> for F {}
+pub trait WidgetIdFn<Rsc, W: ?Sized = dyn Widget>: FnOnce(&mut Rsc) -> WidgetRef<W> {}
+impl<Rsc, W: ?Sized, F: FnOnce(&mut Rsc) -> WidgetRef<W>> WidgetIdFn<Rsc, W> for F {}

 pub trait IdLike {
    type Widget: ?Sized;
@@ -169,3 +169,6 @@ fn null_ptr<W: ?Sized>() -> *const W {
        unsafe { std::mem::transmute_copy(&[0usize; 1]) }
    }
 }
+
+unsafe impl<W: ?Sized> Send for WidgetRef<W> {}
+unsafe impl<W: ?Sized> Sync for WidgetRef<W> {}
--- a/core/src/widget/like.rs
+++ b/core/src/widget/like.rs
@@ -1,55 +1,45 @@
-use crate::{HasUi, Ui};
+use crate::HasUi;

 use super::*;
 use std::marker::Unsize;

-pub trait StateLike<State> {
-    fn as_state(&mut self) -> &mut State;
-}
-
-impl StateLike<Ui> for Ui {
-    fn as_state(&mut self) -> &mut Ui {
-        self
-    }
-}
-
-pub trait WidgetLike<State: HasUi + StateLike<State>, Tag>: Sized {
+pub trait WidgetLike<Rsc: HasUi, Tag>: Sized {
    type Widget: Widget + ?Sized + Unsize<dyn Widget>;

-    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<Self::Widget>;
+    fn add(self, rsc: &mut Rsc) -> WidgetRef<Self::Widget>;

-    fn add_strong(self, state: &mut impl StateLike<State>) -> WidgetHandle<Self::Widget> {
-        self.add(state).upgrade(state.as_state().ui_mut())
+    fn add_strong(self, rsc: &mut Rsc) -> WidgetHandle<Self::Widget> {
+        self.add(rsc).upgrade(rsc.ui_mut())
    }

    fn with_id<W2>(
        self,
-        f: impl FnOnce(&mut State, WidgetRef<Self::Widget>) -> WidgetRef<W2>,
-    ) -> impl WidgetIdFn<State, W2> {
+        f: impl FnOnce(&mut Rsc, WidgetRef<Self::Widget>) -> WidgetRef<W2>,
+    ) -> impl WidgetIdFn<Rsc, W2> {
        move |state| {
            let id = self.add(state);
            f(state, id)
        }
    }

-    fn set_root(self, state: &mut impl StateLike<State>) {
+    fn set_root(self, state: &mut Rsc) {
        let id = self.add(state);
-        let ui = state.as_state().ui_mut();
+        let ui = state.ui_mut();
        ui.root = Some(id.upgrade(ui));
    }

-    fn handles(self, state: &mut impl StateLike<State>) -> WidgetHandles<Self::Widget> {
-        self.add(state).upgrade(state.as_state().ui_mut()).handles()
+    fn handles(self, state: &mut Rsc) -> WidgetHandles<Self::Widget> {
+        self.add(state).upgrade(state.ui_mut()).handles()
    }
 }

-pub trait WidgetArrLike<State, const LEN: usize, Tag> {
+pub trait WidgetArrLike<Rsc, const LEN: usize, Tag> {
    #[track_caller]
-    fn add(self, state: &mut impl StateLike<State>) -> WidgetArr<LEN>;
+    fn add(self, state: &mut Rsc) -> WidgetArr<LEN>;
 }

-impl<State, const LEN: usize> WidgetArrLike<State, LEN, ArrTag> for WidgetArr<LEN> {
-    fn add(self, _: &mut impl StateLike<State>) -> WidgetArr<LEN> {
+impl<Rsc, const LEN: usize> WidgetArrLike<Rsc, LEN, ArrTag> for WidgetArr<LEN> {
+    fn add(self, _: &mut Rsc) -> WidgetArr<LEN> {
        self
    }
 }
@@ -60,12 +50,12 @@ macro_rules! impl_widget_arr {
        impl_widget_arr!($n;$($W)*;$(${concat($W,Tag)})*);
    };
    ($n:expr;$($W:ident)*;$($Tag:ident)*) => {
-        impl<State: HasUi + StateLike<State>, $($W: WidgetLike<State, $Tag>,$Tag,)*> WidgetArrLike<State, $n, ($($Tag,)*)> for ($($W,)*) {
-            fn add(self, state: &mut impl StateLike<State>) -> WidgetArr<$n> {
+        impl<Rsc: HasUi, $($W: WidgetLike<Rsc, $Tag>,$Tag,)*> WidgetArrLike<Rsc, $n, ($($Tag,)*)> for ($($W,)*) {
+            fn add(self, rsc: &mut Rsc) -> WidgetArr<$n> {
                #[allow(non_snake_case)]
                let ($($W,)*) = self;
                WidgetArr::new(
-                    [$($W.add(state).upgrade(state.as_state().ui_mut()),)*],
+                    [$($W.add(rsc).upgrade(rsc.ui_mut()),)*],
                )
            }
        }
--- a/core/src/widget/mod.rs
+++ b/core/src/widget/mod.rs
@@ -5,12 +5,14 @@ mod data;
 mod handle;
 mod like;
 mod tag;
+mod view;
 mod widgets;

 pub use data::*;
 pub use handle::*;
 pub use like::*;
 pub use tag::*;
+pub use view::*;
 pub use widgets::*;

 pub trait Widget: Any {
--- a/core/src/widget/tag.rs
+++ b/core/src/widget/tag.rs
@@ -3,56 +3,57 @@ use crate::HasUi;
 use std::marker::Unsize;

 pub struct WidgetTag;
-impl<State: HasUi + StateLike<State>, W: Widget> WidgetLike<State, WidgetTag> for W {
+impl<Rsc: HasUi, W: Widget> WidgetLike<Rsc, WidgetTag> for W {
    type Widget = W;
-    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<W> {
-        state.as_state().get_mut().widgets.add_weak(self)
+    fn add(self, rsc: &mut Rsc) -> WidgetRef<W> {
+        rsc.ui_mut().widgets.add_weak(self)
    }
 }

 pub struct FnTag;
-impl<State: HasUi + StateLike<State>, W: Widget, F: FnOnce(&mut State) -> W>
-    WidgetLike<State, FnTag> for F
-{
+impl<Rsc: HasUi, W: Widget, F: FnOnce(&mut Rsc) -> W> WidgetLike<Rsc, FnTag> for F {
    type Widget = W;
-    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<W> {
-        self(state.as_state()).add(state)
+    fn add(self, rsc: &mut Rsc) -> WidgetRef<W> {
+        self(rsc).add(rsc)
    }
 }

-pub trait WidgetFnTrait<State> {
+pub trait WidgetFnTrait<Rsc> {
    type Widget: Widget;
-    fn run(self, state: &mut State) -> Self::Widget;
+    fn run(self, rsc: &mut Rsc) -> Self::Widget;
 }
 pub struct FnTraitTag;
-impl<State: HasUi + StateLike<State>, T: WidgetFnTrait<State>> WidgetLike<State, FnTraitTag> for T {
+impl<Rsc: HasUi, T: WidgetFnTrait<Rsc>> WidgetLike<Rsc, FnTraitTag> for T {
    type Widget = T::Widget;
    #[track_caller]
-    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<T::Widget> {
-        self.run(state.as_state()).add(state)
+    fn add(self, rsc: &mut Rsc) -> WidgetRef<T::Widget> {
+        self.run(rsc).add(rsc)
    }
 }

-pub struct IdTag;
-impl<State: HasUi + StateLike<State>, W: ?Sized + Widget + Unsize<dyn Widget>>
-    WidgetLike<State, IdTag> for WidgetRef<W>
-{
+pub struct RefTag;
+impl<Rsc: HasUi, W: ?Sized + Widget + Unsize<dyn Widget>> WidgetLike<Rsc, RefTag> for WidgetRef<W> {
    type Widget = W;
-    fn add(self, _: &mut impl StateLike<State>) -> WidgetRef<W> {
+    fn add(self, _: &mut Rsc) -> WidgetRef<W> {
        self
    }
 }

-pub struct IdFnTag;
-impl<
-    State: HasUi + StateLike<State>,
-    W: ?Sized + Widget + Unsize<dyn Widget>,
-    F: FnOnce(&mut State) -> WidgetRef<W>,
-> WidgetLike<State, IdFnTag> for F
+pub struct RefFnTag;
+impl<Rsc: HasUi, W: ?Sized + Widget + Unsize<dyn Widget>, F: FnOnce(&mut Rsc) -> WidgetRef<W>>
+    WidgetLike<Rsc, RefFnTag> for F
 {
    type Widget = W;
-    fn add(self, state: &mut impl StateLike<State>) -> WidgetRef<W> {
-        self(state.as_state())
+    fn add(self, rsc: &mut Rsc) -> WidgetRef<W> {
+        self(rsc)
+    }
+}
+
+pub struct ViewTag;
+impl<Rsc: HasUi, V: WidgetView> WidgetLike<Rsc, ViewTag> for V {
+    type Widget = V::Widget;
+    fn add(self, _: &mut Rsc) -> WidgetRef<Self::Widget> {
+        self.root()
    }
 }

--- a/core/src/widget/view.rs
+++ b/core/src/widget/view.rs
@@ -0,0 +1,16 @@
+use std::marker::Unsize;
+
+use crate::{Widget, WidgetRef};
+
+pub trait WidgetView {
+    type Widget: Widget + ?Sized + Unsize<dyn Widget>;
+    fn root(&self) -> WidgetRef<Self::Widget>;
+}
+
+pub trait HasWidget {
+    type Widget: Widget + ?Sized + Unsize<dyn Widget>;
+}
+
+impl<W: Widget + Unsize<dyn Widget> + ?Sized> HasWidget for WidgetRef<W> {
+    type Widget = W;
+}
--- a/examples/minimal.rs
+++ b/examples/minimal.rs
@@ -1,20 +1,17 @@
 use iris::prelude::*;

 fn main() {
-    App::<State>::run();
+    DefaultApp::<State>::run();
 }

-#[default_ui_state]
-struct State {}
+#[derive(DefaultUiState)]
+struct State {
+    ui_state: DefaultUiState,
+}

 impl DefaultAppState for State {
-    fn new(ui_state: DefaultUiState, _proxy: Proxy<Self::Event>) -> Self {
-        let mut ui = Ui::new();
-        rect(Color::RED).set_root(&mut ui);
-        Self {
-            ui,
-            ui_state,
-            events: EventManager::default(),
-        }
+    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self::Event>) -> Self {
+        rect(Color::RED).set_root(rsc);
+        Self { ui_state }
    }
 }
--- a/examples/tabs/assets/sungals.png
+++ b/examples/tabs/assets/sungals.png
--- a/examples/tabs/main.rs
+++ b/examples/tabs/main.rs
@@ -2,25 +2,21 @@ use cosmic_text::Family;
 use std::{cell::RefCell, rc::Rc};
 use winit::event::WindowEvent;

-iris::state_prelude!(ClientRsc);
+use iris::prelude::*;
+type ClientRsc = DefaultRsc<Client>;

 fn main() {
-    App::<Client>::run();
+    DefaultApp::<Client>::run();
 }

-#[default_ui_state]
+#[derive(DefaultUiState)]
 pub struct Client {
+    ui_state: DefaultUiState,
    info: WidgetRef<Text>,
 }

 impl DefaultAppState for Client {
-    fn new(ui_state: DefaultUiState, _proxy: Proxy<Self::Event>) -> Self {
-        let mut rsc = ClientRsc {
-            ui: Ui::new(),
-            ui_state,
-            events: EventManager::default(),
-        };
-
+    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self::Event>) -> Self {
        let rrect = rect(Color::WHITE).radius(20);
        let pad_test = (
            rrect.color(Color::BLUE),
@@ -43,7 +39,7 @@ impl DefaultAppState for Client {
                .width(rest(3)),
        )
            .span(Dir::RIGHT)
-            .add(&mut rsc);
+            .add(rsc);

        let span_test = (
            rrect.color(Color::GREEN).width(100),
@@ -54,30 +50,30 @@ impl DefaultAppState for Client {
            rrect.color(Color::RED).width(100),
        )
            .span(Dir::LEFT)
-            .add(&mut rsc);
+            .add(rsc);

-        let span_add = Span::empty(Dir::RIGHT).add(&mut rsc);
+        let span_add = Span::empty(Dir::RIGHT).add(rsc);

        let add_button = rect(Color::LIME)
            .radius(30)
-            .on(CursorSense::click(), move |ctx| {
+            .on(CursorSense::click(), move |_, rsc| {
                let child = image(include_bytes!("assets/sungals.png"))
                    .center()
-                    .add_strong(ctx);
-                span_add(ctx).push(child);
+                    .add_strong(rsc);
+                span_add(rsc).push(child);
            })
            .sized((150, 150))
            .align(Align::BOT_RIGHT);

        let del_button = rect(Color::RED)
            .radius(30)
-            .on(CursorSense::click(), move |ctx| {
-                span_add(ctx).pop();
+            .on(CursorSense::click(), move |_, rsc| {
+                span_add(rsc).pop();
            })
            .sized((150, 150))
            .align(Align::BOT_LEFT);

-        let span_add_test = (span_add, add_button, del_button).stack().add(&mut rsc);
+        let span_add_test = (span_add, add_button, del_button).stack().add(rsc);

        let btext = |content| wtext(content).size(30);

@@ -100,18 +96,18 @@ impl DefaultAppState for Client {
            wtext("pretty cool right?").size(50),
        )
            .span(Dir::DOWN)
-            .add(&mut rsc);
+            .add(rsc);

-        let texts = Span::empty(Dir::DOWN).gap(10).add(&mut rsc);
+        let texts = Span::empty(Dir::DOWN).gap(10).add(rsc);
        let msg_area = texts.scrollable().masked().background(rect(Color::SKY));
        let add_text = wtext("add")
            .editable(EditMode::MultiLine)
            .text_align(Align::LEFT)
            .size(30)
            .attr::<Selectable>(())
-            .on(Submit, move |ctx| {
+            .on(Submit, move |ctx, rsc| {
                let w = ctx.widget;
-                let content = w.edit(ctx).take();
+                let content = w.edit(rsc).take();
                let text = wtext(content)
                    .editable(EditMode::MultiLine)
                    .size(30)
@@ -120,10 +116,11 @@ impl DefaultAppState for Client {
                    .attr::<Selectable>(());
                let msg_box = text
                    .background(rect(Color::WHITE.darker(0.5)))
-                    .add_strong(ctx);
-                texts(ctx).push(msg_box);
+                    .add_strong(rsc);
+                texts(rsc).push(msg_box);
            })
-            .add(&mut rsc);
+            .add(rsc);
+
        let text_edit_scroll = (
            msg_area.height(rest(1)),
            (
@@ -131,8 +128,8 @@ impl DefaultAppState for Client {
                (
                    add_text.width(rest(1)),
                    Rect::new(Color::GREEN)
-                        .on(CursorSense::click(), move |ctx| {
-                            ctx.state.run_event::<Submit>(add_text, &mut ());
+                        .on(CursorSense::click(), move |ctx, rsc: &mut ClientRsc| {
+                            rsc.run_event::<Submit>(add_text, (), ctx.state);
                        })
                        .sized((40, 40)),
                )
@@ -145,39 +142,39 @@ impl DefaultAppState for Client {
                .align(Align::BOT),
        )
            .span(Dir::DOWN)
-            .add(&mut rsc);
+            .add(rsc);

-        let main = WidgetPtr::new().add(&mut rsc);
+        let main = WidgetPtr::new().add(rsc);

        let vals = Rc::new(RefCell::new((0, Vec::new())));
        let mut switch_button = |color, to: WidgetRef, label| {
-            let to = to.upgrade(&mut rsc);
+            let to = to.upgrade(rsc);
            let vec = &mut vals.borrow_mut().1;
            let i = vec.len();
            if vec.is_empty() {
                vec.push(None);
-                rsc.ui[main].set(to);
+                main(rsc).set(to);
            } else {
                vec.push(Some(to));
            }
            let vals = vals.clone();
            let rect = rect(color)
-                .on(CursorSense::click(), move |ctx| {
+                .on(CursorSense::click(), move |ctx, rsc| {
                    let (prev, vec) = &mut *vals.borrow_mut();
                    if let Some(h) = vec[i].take() {
-                        vec[*prev] = main(ctx).replace(h);
+                        vec[*prev] = main(rsc).replace(h);
                        *prev = i;
                    }
-                    ctx.widget().color = color.darker(0.3);
+                    ctx.widget(rsc).color = color.darker(0.3);
                })
                .on(
                    CursorSense::HoverStart | CursorSense::unclick(),
-                    move |ctx| {
-                        ctx.widget().color = color.brighter(0.2);
+                    move |ctx, rsc| {
+                        ctx.widget(rsc).color = color.brighter(0.2);
                    },
                )
-                .on(CursorSense::HoverEnd, move |ctx| {
-                    ctx.widget().color = color;
+                .on(CursorSense::HoverEnd, move |ctx, rsc| {
+                    ctx.widget(rsc).color = color;
                });
            (rect, wtext(label).size(30).text_align(Align::CENTER)).stack()
        };
@@ -195,30 +192,25 @@ impl DefaultAppState for Client {
        )
            .span(Dir::RIGHT);

-        let info = wtext("").add(&mut rsc);
+        let info = wtext("").add(rsc);
        let info_sect = info.pad(10).align(Align::RIGHT);

        ((tabs.height(40), main.pad(10)).span(Dir::DOWN), info_sect)
            .stack()
-            .set_root(&mut rsc);
+            .set_root(rsc);

-        Self {
-            ui: rsc.ui,
-            ui_state: rsc.ui_state,
-            events: rsc.events,
-            info,
-        }
+        Self { ui_state, info }
    }

-    fn window_event(&mut self, _: WindowEvent) {
+    fn window_event(&mut self, _: WindowEvent, rsc: &mut DefaultRsc<Self>) {
        let new = format!(
-            "widgets: {}\nactive:{}\nviews: {}",
-            self.ui.num_widgets(),
-            self.ui.active_widgets(),
+            "widgets: {}\nactive: {}\nviews: {}",
+            rsc.ui.num_widgets(),
+            rsc.ui.active_widgets(),
            self.ui_state.renderer.ui.view_count()
        );
-        if new != *self.ui[self.info].content {
-            *self.ui[self.info].content = new;
+        if new != *rsc.ui[self.info].content {
+            *rsc.ui[self.info].content = new;
        }
    }
 }
--- a/examples/task.rs
+++ b/examples/task.rs
@@ -0,0 +1,30 @@
+use iris::prelude::*;
+use std::time::Duration;
+
+fn main() {
+    DefaultApp::<State>::run();
+}
+
+#[derive(DefaultUiState)]
+struct State {
+    ui_state: DefaultUiState,
+}
+
+impl DefaultAppState for State {
+    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self::Event>) -> Self {
+        let rect = rect(Color::RED).add(rsc);
+        rect.task_on(CursorSense::click(), async move |mut ctx| {
+            tokio::time::sleep(Duration::from_secs(1)).await;
+            ctx.task.update(move |_, rsc| {
+                let rect = rect(rsc);
+                if rect.color == Color::RED {
+                    rect.color = Color::BLUE;
+                } else {
+                    rect.color = Color::RED;
+                }
+            });
+        })
+        .set_root(rsc);
+        Self { ui_state }
+    }
+}
--- a/examples/view.rs
+++ b/examples/view.rs
@@ -0,0 +1,46 @@
+use iris::prelude::*;
+
+fn main() {
+    DefaultApp::<State>::run();
+}
+
+#[derive(DefaultUiState)]
+struct State {
+    ui_state: DefaultUiState,
+}
+
+type Rsc = DefaultRsc<State>;
+
+#[derive(Clone, Copy, WidgetView)]
+struct Test {
+    #[root]
+    root: WidgetRef<Rect>,
+}
+
+impl Test {
+    pub fn new(rsc: &mut Rsc) -> Self {
+        let root = rect(Color::RED).add(rsc);
+        Self { root }
+    }
+    pub fn toggle(&self, rsc: &mut Rsc) {
+        let rect = (self.root)(rsc);
+        if rect.color == Color::RED {
+            rect.color = Color::BLUE;
+        } else {
+            rect.color = Color::RED;
+        }
+    }
+}
+
+impl DefaultAppState for State {
+    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, _: Proxy<Self::Event>) -> Self {
+        let test = Test::new(rsc);
+
+        test.on(CursorSense::click(), move |_, rsc| {
+            test.toggle(rsc);
+        })
+        .set_root(rsc);
+
+        Self { ui_state }
+    }
+}
--- a/macro/src/lib.rs
+++ b/macro/src/lib.rs
@@ -2,8 +2,8 @@ extern crate proc_macro;
 use proc_macro::TokenStream;
 use quote::quote;
 use syn::{
-    Attribute, Block, Error, Fields, FieldsNamed, GenericParam, Generics, Ident, ItemStruct,
-    ItemTrait, Meta, Signature, Token, Visibility,
+    Attribute, Block, Error, GenericParam, Generics, Ident, ItemStruct, ItemTrait, Signature,
+    Token, Type, Visibility,
    parse::{Parse, ParseStream, Result},
    parse_macro_input, parse_quote,
    spanned::Spanned,
@@ -89,104 +89,108 @@ pub fn widget_trait(input: TokenStream) -> TokenStream {
    quote! {
        #trai

-        impl #generics #name<State, WL, Tag> for WL {
+        impl #generics #name<Rsc, WL, Tag> for WL {
            #(#impls)*
        }
    }
    .into()
 }

-#[proc_macro_derive(UiState, attributes(rsc))]
-pub fn derive_ui_state(input: TokenStream) -> TokenStream {
+#[proc_macro_derive(DefaultUiState, attributes(default_ui_state))]
+pub fn derive_default_ui_state(input: TokenStream) -> TokenStream {
    let mut output = proc_macro2::TokenStream::new();

    let state: ItemStruct = parse_macro_input!(input);
-    let sname = state.ident;
-    let rscname = Ident::new(&(sname.to_string() + "Rsc"), sname.span());
-    let mut rsc_fields = Vec::new();

-    for field in state.fields {
-        let Some(attr) = field.attrs.iter().find(|a| a.path().is_ident("rsc")) else {
+    let mut found_attr = false;
+    let mut state_field = None;
+    for field in &state.fields {
+        if !found_attr
+            && let Type::Path(path) = &field.ty
+            && path.path.is_ident("DefaultUiState")
+        {
+            state_field = Some(field);
+        }
+        let Some(attr) = field
+            .attrs
+            .iter()
+            .find(|a| a.path().is_ident("default_ui_state"))
+        else {
            continue;
        };
-        let Meta::List(list) = &attr.meta else {
-            output.extend(Error::new(attr.span(), "invalid attr syntax").into_compile_error());
-            continue;
-        };
-        let tname: Ident = match list.parse_args::<Ident>() {
-            Ok(ident) => ident,
-            Err(err) => {
-                output.extend(err.to_compile_error());
+        if found_attr {
+            output.extend(
+                Error::new(
+                    attr.span(),
+                    "cannot have more than one default_ui_state attribute",
+                )
+                .into_compile_error(),
+            );
            continue;
        }
+        found_attr = true;
+        state_field = Some(field);
+    }
+    let Some(field) = state_field else {
+        output.extend(
+            Error::new(state.ident.span(), "no DefaultUiState field found").into_compile_error(),
+        );
+        return output.into();
    };
-        let fty = &field.ty;
-        let fname = &field.ident.unwrap();
-        rsc_fields.extend(quote! {#fname: #fty,});
+    let sname = &state.ident;
+    let fname = field.ident.as_ref().unwrap();
    output.extend(quote! {
-            impl #tname for #sname {
-                fn get(&self) -> &#fty {
+        impl iris::default::HasDefaultUiState for #sname {
+            fn default_state(&self) -> &iris::default::DefaultUiState {
                &self.#fname
            }
-                fn get_mut(&mut self) -> &mut #fty {
+            fn default_state_mut(&mut self) -> &mut iris::default::DefaultUiState {
                &mut self.#fname
            }
        }
-            impl #tname for #rscname {
-                fn get(&self) -> &#fty {
-                    &self.#fname
-                }
-                fn get_mut(&mut self) -> &mut #fty {
-                    &mut self.#fname
-                }
-            }
-        });
-    }
-    let vis = state.vis;
-    output.extend(quote! {
-        #vis struct #rscname {
-            #(#rsc_fields)*
-        }
-
-        impl HasState for #sname {
-            type State = #sname;
-        }
-
-        impl HasState for #rscname {
-            type State = #sname;
-        }
-
-        impl StateLike<#sname> for #sname {
-            fn as_state(&mut self) -> &mut Self {
-                self
-            }
-        }
-
-        impl StateLike<#rscname> for #rscname {
-            fn as_state(&mut self) -> &mut Self {
-                self
-            }
-        }
    });
    output.into()
 }

-#[proc_macro_attribute]
-pub fn default_ui_state(_attr: TokenStream, input: TokenStream) -> TokenStream {
-    let mut state: ItemStruct = parse_macro_input!(input);
-    let Fields::Named(fields) = &mut state.fields else {
-        panic!("must be on named fields struct");
+#[proc_macro_derive(WidgetView, attributes(root))]
+pub fn derive_widget_view(input: TokenStream) -> TokenStream {
+    let mut output = proc_macro2::TokenStream::new();
+
+    let state: ItemStruct = parse_macro_input!(input);
+
+    let mut found_attr = false;
+    let mut state_field = None;
+    for field in &state.fields {
+        let Some(attr) = field.attrs.iter().find(|a| a.path().is_ident("root")) else {
+            continue;
        };
-    let name = &state.ident;
-    state.attrs.push(parse_quote! {#[derive(UiState)]});
-    let new: FieldsNamed = parse_quote! {{
-        #[rsc(HasUi)]
-        pub ui: Ui,
-        #[rsc(HasDefaultUiState)]
-        pub ui_state: DefaultUiState,
-        #[rsc(HasEvents)]
-        pub events: iris::prelude::EventManager<#name>,
-    }};
-    fields.named.extend(new.named);
-    quote! {#state}.into()
+        if found_attr {
+            output.extend(
+                Error::new(attr.span(), "cannot have more than one root widget")
+                    .into_compile_error(),
+            );
+            continue;
+        }
+        found_attr = true;
+        state_field = Some(field);
+    }
+    let Some(field) = state_field else {
+        output.extend(
+            Error::new(state.ident.span(), "no root widget field found (#[root])")
+                .into_compile_error(),
+        );
+        return output.into();
+    };
+    let sname = &state.ident;
+    let fname = field.ident.as_ref().unwrap();
+    let fty = &field.ty;
+    output.extend(quote! {
+        impl iris::core::WidgetView for #sname {
+            type Widget = <#fty as iris::core::HasWidget>::Widget;
+            fn root(&self) -> #fty {
+                self.#fname
+            }
+        }
+    });
+    output.into()
 }
--- a/src/default/app.rs
+++ b/src/default/app.rs
@@ -11,6 +11,13 @@ pub trait AppState {
    fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop);
    fn event(&mut self, event: Self::Event, event_loop: &ActiveEventLoop);
    fn exit(&mut self);
+
+    fn run()
+    where
+        Self: Sized,
+    {
+        App::<Self>::run();
+    }
 }

 pub struct App<State: AppState> {
--- a/src/default/attr.rs
+++ b/src/default/attr.rs
@@ -4,35 +4,36 @@ use winit::dpi::{LogicalPosition, LogicalSize};

 pub struct Selector;

-impl<State: HasEvents, W: Widget + 'static> WidgetAttr<State, W> for Selector
+impl<Rsc: HasEvents, W: Widget + 'static> WidgetAttr<Rsc, W> for Selector
 where
-    State::State: HasDefaultUiState,
+    Rsc::State: HasDefaultUiState,
 {
    type Input = WidgetRef<TextEdit>;

-    fn run(state: &mut State, container: WidgetRef<W>, id: Self::Input) {
-        state.register_event(container, CursorSense::click_or_drag(), move |ctx| {
-            let region = ctx.ui().window_region(&id).unwrap();
+    fn run(rsc: &mut Rsc, container: WidgetRef<W>, id: Self::Input) {
+        rsc.register_event(container, CursorSense::click_or_drag(), move |ctx, rsc| {
+            let region = rsc.ui().window_region(&id).unwrap();
            let id_pos = region.top_left;
-            let container_pos = ctx.state.ui().window_region(&container).unwrap().top_left;
+            let container_pos = rsc.ui().window_region(&container).unwrap().top_left;
            let pos = ctx.data.pos + container_pos - id_pos;
            let size = region.size();
-            select(ctx.state, id, pos, size, ctx.data.sense.is_dragging());
+            select(rsc, ctx.state, id, pos, size, ctx.data.sense.is_dragging());
        });
    }
 }

 pub struct Selectable;

-impl<State: HasEvents> WidgetAttr<State, TextEdit> for Selectable
+impl<Rsc: HasEvents> WidgetAttr<Rsc, TextEdit> for Selectable
 where
-    State::State: HasDefaultUiState,
+    Rsc::State: HasDefaultUiState,
 {
    type Input = ();

-    fn run(state: &mut State, id: WidgetRef<TextEdit>, _: Self::Input) {
-        state.register_event(id, CursorSense::click_or_drag(), move |ctx| {
+    fn run(rsc: &mut Rsc, id: WidgetRef<TextEdit>, _: Self::Input) {
+        rsc.register_event(id, CursorSense::click_or_drag(), move |ctx, rsc| {
            select(
+                rsc,
                ctx.state,
                id,
                ctx.data.pos,
@@ -44,18 +45,19 @@ where
 }

 fn select(
+    rsc: &mut impl HasUi,
    state: &mut impl HasDefaultUiState,
    id: WidgetRef<TextEdit>,
    pos: Vec2,
    size: Vec2,
    dragging: bool,
 ) {
-    let (ui, state) = HasDefaultUiState::ui_with_state(state);
+    let state = state.default_state_mut();
    let now = Instant::now();
    let recent = (now - state.last_click) < Duration::from_millis(300);
    state.last_click = now;
-    id.edit(ui).select(pos, size, dragging, recent);
-    if let Some(region) = ui.window_region(&id) {
+    id.edit(rsc).select(pos, size, dragging, recent);
+    if let Some(region) = rsc.ui().window_region(&id) {
        state.window.set_ime_allowed(true);
        state.window.set_ime_cursor_area(
            LogicalPosition::<f32>::from(region.top_left.tuple()),
--- a/src/default/mod.rs
+++ b/src/default/mod.rs
@@ -1,7 +1,10 @@
 use crate::prelude::*;
 use arboard::Clipboard;
-use iris_core::util::forget_mut;
-use std::{marker::Sized, sync::Arc, time::Instant};
+use std::{
+    marker::{PhantomData, Sized},
+    sync::Arc,
+    time::Instant,
+};
 use winit::{
    event::{Ime, WindowEvent},
    event_loop::{ActiveEventLoop, EventLoopProxy},
@@ -14,6 +17,7 @@ mod event;
 mod input;
 mod render;
 mod sense;
+mod task;

 pub use app::*;
 pub use attr::*;
@@ -21,6 +25,7 @@ pub use event::*;
 pub use input::*;
 pub use render::*;
 pub use sense::*;
+pub use task::*;

 pub type Proxy<Event> = EventLoopProxy<Event>;

@@ -49,53 +54,111 @@ impl DefaultUiState {
    }
 }

-pub trait HasDefaultUiState: Sized + 'static + HasUi {
-    fn get(&self) -> &DefaultUiState;
-    fn get_mut(&mut self) -> &mut DefaultUiState;
-    fn ui_state(&self) -> &DefaultUiState {
-        HasDefaultUiState::get(self)
-    }
-    fn ui_state_mut(&mut self) -> &mut DefaultUiState {
-        HasDefaultUiState::get_mut(self)
-    }
-    fn ui_with_state(&mut self) -> (&mut Ui, &mut DefaultUiState) {
-        // as long as you're not doing anything actually unhinged this should always work safely
-        (
-            unsafe { forget_mut(self.ui_mut()) },
-            HasDefaultUiState::get_mut(self),
-        )
-    }
+pub trait HasDefaultUiState: Sized + 'static {
+    fn default_state(&self) -> &DefaultUiState;
+    fn default_state_mut(&mut self) -> &mut DefaultUiState;
 }

-pub trait DefaultAppState: RunEvents + HasDefaultUiState {
-    type Event: 'static = ();
-    fn new(ui_state: DefaultUiState, proxy: Proxy<Self::Event>) -> Self;
+pub trait DefaultAppState: HasDefaultUiState {
+    type Event = ();
+    fn new(ui_state: DefaultUiState, rsc: &mut DefaultRsc<Self>, proxy: Proxy<Self::Event>)
+    -> Self;
    #[allow(unused_variables)]
-    fn event(&mut self, event: Self::Event) {}
+    fn event(&mut self, event: Self::Event, rsc: &mut DefaultRsc<Self>) {}
    #[allow(unused_variables)]
-    fn exit(&mut self) {}
+    fn exit(&mut self, rsc: &mut DefaultRsc<Self>) {}
    #[allow(unused_variables)]
-    fn window_event(&mut self, event: WindowEvent) {}
+    fn window_event(&mut self, event: WindowEvent, rsc: &mut DefaultRsc<Self>) {}
    fn window_attributes() -> WindowAttributes {
        Default::default()
    }
 }

-impl<State: DefaultAppState> AppState for State {
+pub struct DefaultRsc<State: 'static> {
+    pub ui: Ui,
+    pub events: EventManager<Self>,
+    pub tasks: Tasks<Self>,
+    _state: PhantomData<State>,
+}
+
+impl<State> DefaultRsc<State> {
+    fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Self>) {
+        let (tasks, recv) = Tasks::init(window);
+        (
+            Self {
+                ui: Default::default(),
+                events: Default::default(),
+                tasks,
+                _state: Default::default(),
+            },
+            recv,
+        )
+    }
+}
+
+impl<State> HasUi for DefaultRsc<State> {
+    fn ui(&self) -> &Ui {
+        &self.ui
+    }
+
+    fn ui_mut(&mut self) -> &mut Ui {
+        &mut self.ui
+    }
+}
+
+impl<State: 'static> HasState for DefaultRsc<State> {
+    type State = State;
+}
+
+impl<State: 'static> HasEvents for DefaultRsc<State> {
+    fn events(&self) -> &EventManager<Self> {
+        &self.events
+    }
+
+    fn events_mut(&mut self) -> &mut EventManager<Self> {
+        &mut self.events
+    }
+}
+
+impl<State: 'static> HasTasks for DefaultRsc<State> {
+    fn tasks_mut(&mut self) -> &mut Tasks<Self> {
+        &mut self.tasks
+    }
+}
+
+pub struct DefaultApp<State: DefaultAppState> {
+    rsc: DefaultRsc<State>,
+    state: State,
+    task_recv: TaskMsgReceiver<DefaultRsc<State>>,
+}
+
+impl<State: DefaultAppState> AppState for DefaultApp<State> {
    type Event = State::Event;

    fn new(event_loop: &ActiveEventLoop, proxy: EventLoopProxy<Self::Event>) -> Self {
-        let window = event_loop.create_window(Self::window_attributes()).unwrap();
-        Self::new(DefaultUiState::new(window), proxy)
+        let window = event_loop
+            .create_window(State::window_attributes())
+            .unwrap();
+        let default_state = DefaultUiState::new(window);
+        let (mut rsc, task_recv) = DefaultRsc::init(default_state.window.clone());
+        let state = State::new(default_state, &mut rsc, proxy);
+        Self {
+            rsc,
+            state,
+            task_recv,
+        }
    }

    fn event(&mut self, event: Self::Event, _: &ActiveEventLoop) {
-        self.event(event);
+        self.state.event(event, &mut self.rsc);
    }

    fn window_event(&mut self, event: WindowEvent, event_loop: &ActiveEventLoop) {
-        let events = unsafe { forget_mut(self.events_mut()) };
-        let ui_state = HasDefaultUiState::get_mut(self);
+        for update in self.task_recv.try_iter() {
+            update(&mut self.state, &mut self.rsc);
+        }
+
+        let ui_state = self.state.default_state_mut();
        let input_changed = ui_state.input.event(&event);
        let cursor_state = ui_state.cursor_state().clone();
        let old = ui_state.focus;
@@ -104,9 +167,11 @@ impl<State: DefaultAppState> AppState for State {
        }
        if input_changed {
            let window_size = ui_state.window_size();
-            self.run_sensors(&cursor_state, window_size);
+            self.rsc
+                .run_sensors(&mut self.state, cursor_state, window_size);
        }
-        let (mut ui, mut ui_state) = self.ui_with_state();
+        let ui = &mut self.rsc.ui;
+        let ui_state = self.state.default_state_mut();
        if old != ui_state.focus
            && let Some(old) = old
        {
@@ -115,7 +180,7 @@ impl<State: DefaultAppState> AppState for State {
        match &event {
            WindowEvent::CloseRequested => event_loop.exit(),
            WindowEvent::RedrawRequested => {
-                ui.update(events);
+                ui.update(&mut self.rsc.events);
                ui_state.renderer.update(ui);
                ui_state.renderer.draw();
            }
@@ -134,13 +199,13 @@ impl<State: DefaultAppState> AppState for State {
                            ui_state.window.set_ime_allowed(false);
                        }
                        TextInputResult::Submit => {
-                            self.run_event::<Submit>(sel, &mut ());
+                            self.rsc.run_event::<Submit>(sel, (), &mut self.state);
                        }
                        TextInputResult::Paste => {
                            if let Ok(t) = ui_state.clipboard.get_text() {
                                text.insert(&t);
                            }
-                            self.run_event::<Edited>(sel, &mut ());
+                            self.rsc.run_event::<Edited>(sel, (), &mut self.state);
                        }
                        TextInputResult::Copy(text) => {
                            if let Err(err) = ui_state.clipboard.set_text(text) {
@@ -148,7 +213,7 @@ impl<State: DefaultAppState> AppState for State {
                            }
                        }
                        TextInputResult::Used => {
-                            self.run_event::<Edited>(sel, &mut ());
+                            self.rsc.run_event::<Edited>(sel, (), &mut self.state);
                        }
                        TextInputResult::Unused => {}
                    }
@@ -172,15 +237,15 @@ impl<State: DefaultAppState> AppState for State {
            }
            _ => (),
        }
-        self.window_event(event);
-        (ui, ui_state) = self.ui_with_state();
-        if ui.needs_redraw() {
+        self.state.window_event(event, &mut self.rsc);
+        let ui_state = self.state.default_state_mut();
+        if self.rsc.ui.needs_redraw() {
            ui_state.renderer.window().request_redraw();
        }
        ui_state.input.end_frame();
    }

    fn exit(&mut self) {
-        self.exit();
+        self.state.exit(&mut self.rsc);
    }
 }
--- a/src/default/render.rs
+++ b/src/default/render.rs
@@ -1,7 +1,7 @@
 use iris_core::{Ui, UiLimits, UiRenderNode};
 use pollster::FutureExt;
 use std::sync::Arc;
-use wgpu::{util::StagingBelt, *};
+use wgpu::*;
 use winit::{dpi::PhysicalSize, window::Window};

 pub const CLEAR_COLOR: Color = Color::BLACK;
@@ -13,7 +13,6 @@ pub struct UiRenderer {
    queue: Queue,
    config: SurfaceConfiguration,
    encoder: CommandEncoder,
-    staging_belt: StagingBelt,
    pub ui: UiRenderNode,
 }

@@ -46,9 +45,7 @@ impl UiRenderer {
        }

        self.queue.submit(std::iter::once(encoder.finish()));
-        self.staging_belt.finish();
        output.present();
-        self.staging_belt.recall();
    }

    pub fn resize(&mut self, size: &PhysicalSize<u32>) {
@@ -126,10 +123,9 @@ impl UiRenderer {

        surface.configure(&device, &config);

-        let staging_belt = StagingBelt::new(4096 * 4);
        let encoder = Self::create_encoder(&device);

-        let shape_pipeline = UiRenderNode::new(&device, &queue, &config, ui_limits);
+        let ui = UiRenderNode::new(&device, &queue, &config, ui_limits);

        Self {
            surface,
@@ -137,8 +133,7 @@ impl UiRenderer {
            queue,
            config,
            encoder,
-            staging_belt,
-            ui: shape_pipeline,
+            ui,
            window,
        }
    }
--- a/src/default/sense.rs
+++ b/src/default/sense.rs
@@ -26,14 +26,15 @@ pub enum CursorSense {
 pub struct CursorSenses(Vec<CursorSense>);

 impl Event for CursorSenses {
-    type Data<'a> = CursorData<'a>;
+    type Data = CursorData;
    type State = SensorState;
-    fn should_run(&self, data: &mut Self::Data<'_>) -> bool {
-        if let Some(sense) = should_run(self, data.cursor, data.hover) {
+    fn should_run(&self, data: &Self::Data) -> Option<Self::Data> {
+        if let Some(sense) = should_run(self, &data.cursor, data.hover) {
+            let mut data = data.clone();
            data.sense = sense;
-            true
+            Some(data)
        } else {
-            false
+            None
        }
    }
 }
@@ -115,7 +116,7 @@ pub enum ActivationState {
 /// or basically have some way to have custom senses
 /// that depend on active widget positions
 /// but I'm not sure how or if worth it
-pub struct Sensor<Ctx, Data> {
+pub struct Sensor<Ctx: HasEvents, Data> {
    pub senses: CursorSenses,
    pub f: Rc<dyn EventFn<Ctx, Data>>,
 }
@@ -127,23 +128,24 @@ pub struct SensorState {
    pub hover: ActivationState,
 }

-pub struct CursorData<'a> {
+#[derive(Clone)]
+pub struct CursorData {
    /// where this widget was hit
    pub pos: Vec2,
    pub size: Vec2,
    pub scroll_delta: Vec2,
    pub hover: ActivationState,
-    pub cursor: &'a CursorState,
+    pub cursor: CursorState,
    /// the first sense that triggered this
    pub sense: CursorSense,
 }

-pub trait SensorUi<State> {
-    fn run_sensors(&mut self, cursor: &CursorState, window_size: Vec2);
+pub trait SensorUi<Rsc: HasEvents> {
+    fn run_sensors(&mut self, state: &mut Rsc::State, cursor: CursorState, window_size: Vec2);
 }

-impl<State: RunEvents> SensorUi<State> for State {
-    fn run_sensors(&mut self, cursor: &CursorState, window_size: Vec2) {
+impl<Rsc: HasEvents> SensorUi<Rsc> for Rsc {
+    fn run_sensors(&mut self, state: &mut Rsc::State, cursor: CursorState, window_size: Vec2) {
        let layers = std::mem::take(&mut self.ui_mut().layers);
        let mut active = std::mem::take(&mut self.events_mut().get_type::<CursorSense>().active);
        for layer in layers.indices().rev() {
@@ -158,7 +160,9 @@ impl<State: RunEvents> SensorUi<State> for State {
                }
                sensed = true;

-                let mut data = CursorData {
+                let cursor = cursor.clone();
+
+                let data = CursorData {
                    pos: cursor.pos - region.top_left,
                    size: region.bot_right - region.top_left,
                    scroll_delta: cursor.scroll_delta,
@@ -168,7 +172,7 @@ impl<State: RunEvents> SensorUi<State> for State {
                    // might wanna set up Event to have a prepare stage
                    sense: CursorSense::Hovering,
                };
-                self.run_event::<CursorSense>(*id, &mut data);
+                self.run_event::<CursorSense>(*id, data, state);
            }
            if sensed {
                break;
--- a/src/default/task.rs
+++ b/src/default/task.rs
@@ -0,0 +1,82 @@
+use iris_core::HasState;
+use std::{
+    pin::Pin,
+    sync::{
+        Arc,
+        mpsc::{Receiver as SyncReceiver, Sender as SyncSender, channel as sync_channel},
+    },
+};
+use tokio::{
+    runtime::Runtime,
+    sync::mpsc::{
+        UnboundedReceiver as AsyncReceiver, UnboundedSender as AsyncSender,
+        unbounded_channel as async_channel,
+    },
+};
+use winit::window::Window;
+
+pub type TaskMsgSender<Rsc> = SyncSender<Box<dyn TaskUpdate<Rsc>>>;
+pub type TaskMsgReceiver<Rsc> = SyncReceiver<Box<dyn TaskUpdate<Rsc>>>;
+
+pub trait TaskUpdate<Rsc: HasState>: FnOnce(&mut Rsc::State, &mut Rsc) + Send {}
+impl<F: FnOnce(&mut Rsc::State, &mut Rsc) + Send, Rsc: HasState> TaskUpdate<Rsc> for F {}
+
+pub struct Tasks<Rsc: HasState> {
+    start: AsyncSender<BoxTask>,
+    window: Arc<Window>,
+    msg_send: SyncSender<Box<dyn TaskUpdate<Rsc>>>,
+}
+
+pub struct TaskCtx<Rsc: HasState> {
+    send: TaskMsgSender<Rsc>,
+}
+
+impl<Rsc: HasState> TaskCtx<Rsc> {
+    pub fn update(&mut self, f: impl TaskUpdate<Rsc> + 'static) {
+        let _ = self.send.send(Box::new(f));
+    }
+}
+impl<Rsc: HasState + 'static> TaskCtx<Rsc> {
+    fn new(send: TaskMsgSender<Rsc>) -> Self {
+        Self { send }
+    }
+}
+
+type BoxTask = Pin<Box<dyn Future<Output = ()> + Send>>;
+
+impl<Rsc: HasState> Tasks<Rsc> {
+    pub fn init(window: Arc<Window>) -> (Self, TaskMsgReceiver<Rsc>) {
+        let (start, start_recv) = async_channel();
+        let (msgs, msgs_recv) = sync_channel();
+        std::thread::spawn(|| {
+            let rt = Runtime::new().unwrap();
+            rt.block_on(listen(start_recv))
+        });
+        (
+            Self {
+                start,
+                msg_send: msgs,
+                window,
+            },
+            msgs_recv,
+        )
+    }
+
+    pub fn spawn<F: AsyncFnOnce(TaskCtx<Rsc>) + 'static + std::marker::Send>(&mut self, task: F)
+    where
+        F::CallOnceFuture: Send,
+    {
+        let send = self.msg_send.clone();
+        let window = self.window.clone();
+        let _ = self.start.send(Box::pin(async move {
+            task(TaskCtx::new(send)).await;
+            window.request_redraw();
+        }));
+    }
+}
+
+async fn listen(mut recv: AsyncReceiver<BoxTask>) {
+    while let Some(task) = recv.recv().await {
+        tokio::spawn(task);
+    }
+}
--- a/src/event.rs
+++ b/src/event.rs
@@ -1,25 +1,81 @@
-use crate::prelude::*;
+use iris_core::*;
+use iris_macro::*;
+use std::sync::Arc;

-pub mod eventable {
-    use super::*;
-    widget_trait! {
-        pub trait Eventable<State: HasEvents + StateLike<State> + 'static>;
+use crate::default::{TaskCtx, Tasks};
+
+pub trait Eventable<Rsc: HasEvents, Tag>: WidgetLike<Rsc, Tag> {
    fn on<E: EventLike>(
        self,
        event: E,
-            f: impl for<'a> WidgetEventFn<State::State, <E::Event as Event>::Data<'a>, WL::Widget>,
-        ) -> impl WidgetIdFn<State, WL::Widget> {
-            move |state| {
-                let id = self.add(state);
-                state.register_event(id, event.into_event(), move |ctx| {
-                    f(&mut EventIdCtx {
+        f: impl WidgetEventFn<Rsc, <E::Event as Event>::Data, Self::Widget>,
+    ) -> impl WidgetIdFn<Rsc, Self::Widget> {
+        move |rsc| {
+            let id = self.add(rsc);
+            rsc.register_event(id, event.into_event(), move |ctx, rsc| {
+                f(
+                    EventIdCtx {
                        widget: id,
                        state: ctx.state,
                        data: ctx.data,
+                    },
+                    rsc,
+                );
+            });
+            id
+        }
+    }
+}
+impl<WL: WidgetLike<Rsc, Tag>, Rsc: HasEvents, Tag> Eventable<Rsc, Tag> for WL {}
+
+widget_trait! {
+    pub trait TaskEventable<Rsc: HasEvents + HasTasks>;
+    fn task_on<E: EventLike, F: AsyncWidgetEventFn<Rsc, <E::Event as Event>::Data, WL::Widget>>(
+        self,
+        event: E,
+        f: F,
+    ) -> impl WidgetIdFn<Rsc, WL::Widget>
+        where <E::Event as Event>::Data: Send,
+        for<'a> F::CallRefFuture<'a>: Send,
+    {
+        let f = Arc::new(f);
+        move |rsc| {
+            let id = self.add(rsc);
+            rsc.register_event(id, event.into_event(), move |ctx, rsc| {
+                let data = ctx.data;
+                let f = f.clone();
+                rsc.tasks_mut().spawn(async move |task| {
+                    f(AsyncEventIdCtx {
+                        widget: id,
+                        data,
+                        task,
+                    }).await;
                });
            });
            id
        }
    }
-    }
+}
+
+pub trait HasTasks: Sized + HasState + HasEvents {
+    fn tasks_mut(&mut self) -> &mut Tasks<Self>;
+}
+
+pub trait AsyncWidgetEventFn<Rsc: HasEvents, Data, W: ?Sized>:
+    AsyncFn(AsyncEventIdCtx<Rsc, Data, W>) + Send + Sync + 'static
+{
+}
+impl<
+    Rsc: HasEvents,
+    F: AsyncFn(AsyncEventIdCtx<Rsc, Data, W>) + Send + Sync + 'static,
+    Data,
+    W: ?Sized,
+> AsyncWidgetEventFn<Rsc, Data, W> for F
+{
+}
+
+pub struct AsyncEventIdCtx<Rsc: HasEvents, Data, W: ?Sized> {
+    pub widget: WidgetRef<W>,
+    pub data: Data,
+    pub task: TaskCtx<Rsc>,
 }
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,28 +4,15 @@
 #![feature(associated_type_defaults)]
 #![feature(unsize)]
 #![feature(option_into_flat_iter)]
+#![feature(async_fn_traits)]

 pub mod default;
 pub mod event;
-pub mod typed;
 pub mod widget;

 pub use iris_core as core;
 pub use iris_macro as macros;

-#[macro_export]
-macro_rules! state_prelude {
-    ($vis:vis $state:ty) => {
-        iris::event_state!($vis $state);
-        $vis use iris::{
-            default::*,
-            core::{len_fns::*, util::Vec2, *},
-            macros::*,
-            widget::*,
-        };
-    };
-}
-
 pub mod prelude {
    use super::*;
    pub use default::*;
@@ -35,5 +22,5 @@ pub mod prelude {
    pub use widget::*;

    pub use iris_core::util::Vec2;
-    pub use typed::*;
+    pub use len_fns::*;
 }
--- a/src/typed.rs
+++ b/src/typed.rs
@@ -1,37 +0,0 @@
-#[macro_export]
-macro_rules! event_state {
-    ($vis:vis $state:ty) => {
-        mod local_event_trait {
-            use super::*;
-            #[allow(unused_imports)]
-            use $crate::prelude::*;
-            pub trait EventableCtx<WL: WidgetLike<$state, Tag>, Tag> {
-                fn on<E: EventLike>(
-                    self,
-                    event: E,
-                    f: impl for<'a> WidgetEventFn<
-                        <$state as HasState>::State,
-                        <E::Event as Event>::Data<'a>,
-                        WL::Widget
-                    >,
-                ) -> impl WidgetIdFn<$state, WL::Widget>;
-            }
-            impl<WL: WidgetLike<$state, Tag>, Tag> EventableCtx<WL, Tag> for WL {
-                fn on<E: EventLike>(
-                    self,
-                    event: E,
-                    f: impl for<'a> WidgetEventFn<
-                        <$state as HasState>::State,
-                        <E::Event as Event>::Data<'a>,
-                        WL::Widget
-                    >,
-                ) -> impl WidgetIdFn<$state, WL::Widget> {
-                    eventable::Eventable::on(self, event, f)
-                }
-            }
-        }
-        $vis type EventManager = $crate::prelude::EventManager<<$state as HasState>::State>;
-        $vis use local_event_trait::*;
-    };
-}
-pub use event_state;
--- a/src/widget/image.rs
+++ b/src/widget/image.rs
@@ -22,7 +22,7 @@ impl Widget for Image {
 pub fn image<State: HasUi>(image: impl LoadableImage) -> impl WidgetFn<State, Image> {
    let image = image.get_image().expect("Failed to load image");
    move |state| Image {
-        handle: state.get_mut().add_texture(image),
+        handle: state.ui_mut().add_texture(image),
    }
 }

--- a/src/widget/position/span.rs
+++ b/src/widget/position/span.rs
@@ -159,15 +159,15 @@ pub struct SpanBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Ta
    _pd: PhantomData<(State, Tag)>,
 }

-impl<State: StateLike<State>, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
-    WidgetFnTrait<State> for SpanBuilder<State, LEN, Wa, Tag>
+impl<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> WidgetFnTrait<Rsc>
+    for SpanBuilder<Rsc, LEN, Wa, Tag>
 {
    type Widget = Span;

    #[track_caller]
-    fn run(self, state: &mut State) -> Self::Widget {
+    fn run(self, rsc: &mut Rsc) -> Self::Widget {
        Span {
-            children: self.children.add(state).arr.into_iter().collect(),
+            children: self.children.add(rsc).arr.into_iter().collect(),
            dir: self.dir,
            gap: self.gap,
        }
--- a/src/widget/position/stack.rs
+++ b/src/widget/position/stack.rs
@@ -48,14 +48,15 @@ pub struct StackBuilder<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, T
    _pd: PhantomData<(State, Tag)>,
 }

-impl<State: StateLike<State>, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> FnOnce<(&mut State,)>
-    for StackBuilder<State, LEN, Wa, Tag>
+impl<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> WidgetFnTrait<Rsc>
+    for StackBuilder<Rsc, LEN, Wa, Tag>
 {
-    type Output = Stack;
+    type Widget = Stack;

-    extern "rust-call" fn call_once(self, args: (&mut State,)) -> Self::Output {
+    #[track_caller]
+    fn run(self, rsc: &mut Rsc) -> Self::Widget {
        Stack {
-            children: self.children.add(args.0).arr.into_iter().collect(),
+            children: self.children.add(rsc).arr.into_iter().collect(),
            size: self.size,
        }
    }
--- a/src/widget/text/build.rs
+++ b/src/widget/text/build.rs
@@ -51,15 +51,15 @@ impl<State, O, H: WidgetOption<State>> TextBuilder<State, O, H> {
    }
 }

-impl<State: HasUi + StateLike<State>, O> TextBuilder<State, O> {
-    pub fn hint<W: WidgetLike<State, Tag>, Tag>(
+impl<Rsc: HasUi, O> TextBuilder<Rsc, O> {
+    pub fn hint<W: WidgetLike<Rsc, Tag>, Tag>(
        self,
        hint: W,
-    ) -> TextBuilder<State, O, impl WidgetOption<State>> {
+    ) -> TextBuilder<Rsc, O, impl WidgetOption<Rsc>> {
        TextBuilder {
            content: self.content,
            attrs: self.attrs,
-            hint: move |ui: &mut State| Some(hint.add_strong(ui).any()),
+            hint: move |rsc: &mut Rsc| Some(hint.add_strong(rsc).any()),
            output: self.output,
            state: PhantomData,
        }
@@ -75,19 +75,19 @@ pub trait TextBuilderOutput<State>: Sized {
 }

 pub struct TextOutput;
-impl<State: HasUi> TextBuilderOutput<State> for TextOutput {
+impl<Rsc: HasUi> TextBuilderOutput<Rsc> for TextOutput {
    type Output = Text;

-    fn run<H: WidgetOption<State>>(
-        state: &mut State,
-        builder: TextBuilder<State, Self, H>,
+    fn run<H: WidgetOption<Rsc>>(
+        state: &mut Rsc,
+        builder: TextBuilder<Rsc, Self, H>,
    ) -> Self::Output {
        let mut buf = TextBuffer::new_empty(Metrics::new(
            builder.attrs.font_size,
            builder.attrs.line_height,
        ));
        let hint = builder.hint.get(state);
-        let font_system = &mut state.get_mut().text.font_system;
+        let font_system = &mut state.ui_mut().text.font_system;
        buf.set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
        let mut text = Text {
            content: builder.content.into(),
@@ -118,7 +118,7 @@ impl<State: HasUi> TextBuilderOutput<State> for TextEditOutput {
            TextView::new(buf, builder.attrs, builder.hint.get(state)),
            builder.output.mode,
        );
-        let font_system = &mut state.get_mut().text.font_system;
+        let font_system = &mut state.ui_mut().text.font_system;
        text.buf
            .set_text(font_system, &builder.content, &Attrs::new(), SHAPING, None);
        builder.attrs.apply(font_system, &mut text.buf, None);
--- a/src/widget/trait_fns.rs
+++ b/src/widget/trait_fns.rs
@@ -3,35 +3,35 @@ use crate::prelude::*;

 // these methods should "not require any context" (require unit) because they're in core
 widget_trait! {
-    pub trait CoreWidget<State: HasUi + StateLike<State> + 'static>;
+    pub trait CoreWidget<Rsc: HasUi + 'static>;

-    fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<State, Pad> {
+    fn pad(self, padding: impl Into<Padding>) -> impl WidgetFn<Rsc, Pad> {
        |state| Pad {
            padding: padding.into(),
            inner: self.add_strong(state),
        }
    }

-    fn align(self, align: impl Into<Align>) -> impl WidgetFn<State, Aligned> {
+    fn align(self, align: impl Into<Align>) -> impl WidgetFn<Rsc, Aligned> {
        move |state| Aligned {
            inner: self.add_strong(state),
            align: align.into(),
        }
    }

-    fn center(self) -> impl WidgetFn<State, Aligned> {
+    fn center(self) -> impl WidgetFn<Rsc, Aligned> {
        self.align(Align::CENTER)
    }

-    fn label(self, label: impl Into<String>) -> impl WidgetIdFn<State, WL::Widget> {
+    fn label(self, label: impl Into<String>) -> impl WidgetIdFn<Rsc, WL::Widget> {
        |state| {
            let id = self.add(state);
-            state.get_mut().set_label(id, label.into());
+            state.ui_mut().set_label(id, label.into());
            id
        }
    }

-    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<State, Sized> {
+    fn sized(self, size: impl Into<Size>) -> impl WidgetFn<Rsc, Sized> {
        let size = size.into();
        move |state| Sized {
            inner: self.add_strong(state),
@@ -40,7 +40,7 @@ widget_trait! {
        }
    }

-    fn max_width(self, len: impl Into<Len>) -> impl WidgetFn<State, MaxSize> {
+    fn max_width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
        let len = len.into();
        move |state| MaxSize {
            inner: self.add_strong(state),
@@ -49,7 +49,7 @@ widget_trait! {
        }
    }

-    fn max_height(self, len: impl Into<Len>) -> impl WidgetFn<State, MaxSize> {
+    fn max_height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, MaxSize> {
        let len = len.into();
        move |state| MaxSize {
            inner: self.add_strong(state),
@@ -58,7 +58,7 @@ widget_trait! {
        }
    }

-    fn width(self, len: impl Into<Len>) -> impl WidgetFn<State, Sized> {
+    fn width(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
        let len = len.into();
        move |state| Sized {
            inner: self.add_strong(state),
@@ -67,7 +67,7 @@ widget_trait! {
        }
    }

-    fn height(self, len: impl Into<Len>) -> impl WidgetFn<State, Sized> {
+    fn height(self, len: impl Into<Len>) -> impl WidgetFn<Rsc, Sized> {
        let len = len.into();
        move |state| Sized {
            inner: self.add_strong(state),
@@ -76,65 +76,64 @@ widget_trait! {
        }
    }

-    fn offset(self, amt: impl Into<UiVec2>) -> impl WidgetFn<State, Offset> {
+    fn offset(self, amt: impl Into<UiVec2>) -> impl WidgetFn<Rsc, Offset> {
        move |state| Offset {
            inner: self.add_strong(state),
            amt: amt.into(),
        }
    }

-    fn scrollable(self) -> impl WidgetIdFn<State, Scroll> where State: HasEvents {
-        use eventable::*;
+    fn scrollable(self) -> impl WidgetIdFn<Rsc, Scroll> where Rsc: HasEvents {
        move |state| {
            Scroll::new(self.add_strong(state), Axis::Y)
-                .on(CursorSense::Scroll, |ctx: &mut EventIdCtx<'_, State::State, CursorData<'_>, Scroll>| {
+                .on(CursorSense::Scroll, |ctx, rsc| {
                    let delta = ctx.data.scroll_delta.y * 50.0;
-                    ctx.widget().scroll(delta);
+                    ctx.widget(rsc).scroll(delta);
                })
                .add(state)
        }
    }

-    fn masked(self) -> impl WidgetFn<State, Masked> {
+    fn masked(self) -> impl WidgetFn<Rsc, Masked> {
        move |state| Masked {
            inner: self.add_strong(state),
        }
    }

-    fn background<T>(self, w: impl WidgetLike<State, T>) -> impl WidgetFn<State, Stack> {
+    fn background<T>(self, w: impl WidgetLike<Rsc, T>) -> impl WidgetFn<Rsc, Stack> {
        move |state| Stack {
            children: vec![w.add_strong(state), self.add_strong(state)],
            size: StackSize::Child(1),
        }
    }

-    fn foreground<T>(self, w: impl WidgetLike<State, T>) -> impl WidgetFn<State, Stack> {
+    fn foreground<T>(self, w: impl WidgetLike<Rsc, T>) -> impl WidgetFn<Rsc, Stack> {
        move |state| Stack {
            children: vec![self.add_strong(state), w.add_strong(state)],
            size: StackSize::Child(0),
        }
    }

-    fn layer_offset(self, offset: usize) -> impl WidgetFn<State, LayerOffset> {
+    fn layer_offset(self, offset: usize) -> impl WidgetFn<Rsc, LayerOffset> {
        move |state| LayerOffset {
            inner: self.add_strong(state),
            offset,
        }
    }

-    fn to_any(self) -> impl WidgetIdFn<State> {
+    fn to_any(self) -> impl WidgetIdFn<Rsc> {
        |state| self.add(state)
    }

-    fn set_ptr(self, ptr: WidgetRef<WidgetPtr>, state: &mut State) {
+    fn set_ptr(self, ptr: WidgetRef<WidgetPtr>, state: &mut Rsc) {
        let id = self.add_strong(state);
-        state.get_mut()[ptr].inner = Some(id);
+        state.ui_mut()[ptr].inner = Some(id);
    }
 }

-pub trait CoreWidgetArr<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag> {
-    fn span(self, dir: Dir) -> SpanBuilder<State, LEN, Wa, Tag>;
-    fn stack(self) -> StackBuilder<State, LEN, Wa, Tag>;
+pub trait CoreWidgetArr<Rsc, const LEN: usize, Wa: WidgetArrLike<Rsc, LEN, Tag>, Tag> {
+    fn span(self, dir: Dir) -> SpanBuilder<Rsc, LEN, Wa, Tag>;
+    fn stack(self) -> StackBuilder<Rsc, LEN, Wa, Tag>;
 }

 impl<State, const LEN: usize, Wa: WidgetArrLike<State, LEN, Tag>, Tag>
Author	SHA1	Message	Date
shadow cat	a9c76e4326	lol bounds	2026-01-05 17:50:18 -05:00
shadow cat	32e45e9238	griefed last commit	2026-01-05 17:20:11 -05:00
shadow cat	2fadfe4b82	app event stuff bruh	2026-01-05 17:16:56 -05:00
shadow cat	d11107f965	widget view	2026-01-05 17:01:09 -05:00
shadow cat	07de7c8722	update deps	2026-01-04 14:45:18 -05:00
shadow cat	f2ac6f195f	remove typed stuff / just specify rsc if needed	2026-01-03 18:06:05 -05:00
shadow cat	59901b6580	tasks initial impl (still working on task_on trait method)	2026-01-03 16:26:23 -05:00
shadow cat	5da1e9e767	separate state from rsc	2026-01-01 22:18:08 -05:00