diff --git a/crates/gooey-core/src/lib.rs b/crates/gooey-core/src/lib.rs
index f95e2a1cd..d8c513fa6 100644
--- a/crates/gooey-core/src/lib.rs
+++ b/crates/gooey-core/src/lib.rs
@@ -17,6 +17,7 @@ use alot::OrderedLots;
 pub use {figures as math, gooey_reactor as reactor};
 pub mod graphics;
 pub mod style;
+pub mod window;
 // mod tree;
 pub use gooey_macros::Widget;
 use gooey_reactor::{Dynamic, Reactor, Scope, ScopeGuard};
@@ -568,7 +569,9 @@ where
         style: Dynamic<Style>,
         context: &F::Context,
     ) -> F::Instance {
-        let Some(transmogrifier) = self.by_name.get(&widget.name()) else { unreachable!("{} not registered", widget.name()) };
+        let Some(transmogrifier) = self.by_name.get(&widget.name()) else {
+            unreachable!("{} not registered", widget.name())
+        };
         transmogrifier.0.transmogrify(widget, style, context)
     }
 
diff --git a/crates/gooey-core/src/window.rs b/crates/gooey-core/src/window.rs
new file mode 100644
index 000000000..8acc9fe26
--- /dev/null
+++ b/crates/gooey-core/src/window.rs
@@ -0,0 +1,166 @@
+use std::panic::UnwindSafe;
+
+use figures::units::{Px, UPx};
+use figures::{Point, Size};
+use gooey_reactor::Dynamic;
+
+use crate::Context;
+
+#[derive(Default)]
+#[must_use]
+pub struct WindowBuilder {
+    attributes: WindowAttributes,
+}
+
+impl WindowBuilder {
+    pub fn title(mut self, title: impl Into<String>) -> Self {
+        self.attributes.title = title.into();
+        self
+    }
+
+    pub fn level(mut self, level: WindowLevel) -> Self {
+        self.attributes.window_level = level;
+        self
+    }
+
+    pub fn location(mut self, location: Point<Px>) -> Self {
+        self.attributes.location = Some(location);
+        self
+    }
+
+    pub fn resizable(mut self, resizable: bool) -> Self {
+        self.attributes.resizable = resizable;
+        self
+    }
+
+    pub fn inner_size(mut self, size: Size<UPx>) -> Self {
+        self.attributes.inner_size = Some(size);
+        self
+    }
+
+    pub fn create<Widget, Initializer>(self, init: Initializer) -> NewWindow<Widget>
+    where
+        Initializer: FnOnce(&Context, &Window) -> Widget + Send + UnwindSafe + 'static,
+    {
+        NewWindow {
+            attributes: self.attributes,
+            init: Box::new(init),
+        }
+    }
+}
+
+#[allow(clippy::struct_excessive_bools)]
+pub struct WindowAttributes {
+    pub inner_size: Option<Size<UPx>>,
+    pub min_inner_size: Option<Size<UPx>>,
+    pub max_inner_size: Option<Size<UPx>>,
+    pub location: Option<Point<Px>>,
+    pub resizable: bool,
+    pub enabled_buttons: WindowButtons,
+    pub title: String,
+    // pub fullscreen: Option<Fullscreen>,
+    pub maximized: bool,
+    pub visible: bool,
+    pub transparent: bool,
+    pub decorations: bool,
+    // pub window_icon: Option<Icon>,
+    // pub preferred_theme: Option<Theme>,
+    pub resize_increments: Option<Size<UPx>>,
+    pub content_protected: bool,
+    pub window_level: WindowLevel,
+    // pub parent_window: Option<Window<ParentWindowEvent>>,
+    pub active: bool,
+}
+
+impl Default for WindowAttributes {
+    fn default() -> Self {
+        WindowAttributes {
+            inner_size: None,
+            min_inner_size: None,
+            max_inner_size: None,
+            location: None,
+            resizable: true,
+            enabled_buttons: WindowButtons::all(),
+            title: "Gooey".to_owned(),
+            maximized: false,
+            // fullscreen: None,
+            visible: true,
+            transparent: false,
+            decorations: true,
+            window_level: WindowLevel::default(),
+            // window_icon: None,
+            // preferred_theme: None,
+            resize_increments: None,
+            content_protected: false,
+            // parent_window: None,
+            active: true,
+        }
+    }
+}
+
+#[derive(Default, Debug, PartialEq, Eq, Clone, Copy)]
+pub enum WindowLevel {
+    /// The window will always be below normal windows.
+    ///
+    /// This is useful for a widget-based app.
+    AlwaysOnBottom,
+    /// The default.
+    #[default]
+    Normal,
+    /// The window will always be on top of normal windows.
+    AlwaysOnTop,
+}
+
+#[derive(Clone, Copy, Eq, PartialEq)]
+pub struct WindowButtons(u8);
+
+impl WindowButtons {
+    pub const CLOSE: Self = Self(1 << 0);
+    pub const MAXIMIZE: Self = Self(1 << 2);
+    pub const MINIMIZE: Self = Self(1 << 1);
+
+    #[must_use]
+    pub const fn all() -> Self {
+        Self(Self::CLOSE.0 | Self::MAXIMIZE.0 | Self::MINIMIZE.0)
+    }
+
+    #[must_use]
+    pub const fn maximize(&self) -> bool {
+        self.0 & Self::MAXIMIZE.0 != 0
+    }
+
+    #[must_use]
+    pub const fn minimize(&self) -> bool {
+        self.0 & Self::MINIMIZE.0 != 0
+    }
+
+    #[must_use]
+    pub const fn close(&self) -> bool {
+        self.0 & Self::CLOSE.0 != 0
+    }
+}
+
+pub type WindowInitializer<Widget> =
+    Box<dyn FnOnce(&crate::Context, &Window) -> Widget + std::panic::UnwindSafe + Send>;
+
+pub struct NewWindow<Widget> {
+    pub attributes: WindowAttributes,
+    pub init: WindowInitializer<Widget>,
+}
+
+pub struct Window {
+    pub inner_size: Dynamic<Size<UPx>>,
+    pub location: Dynamic<Point<Px>>,
+    pub title: Dynamic<String>,
+}
+
+impl Window {
+    #[must_use]
+    pub fn new(attrs: WindowAttributes, cx: &Context) -> Self {
+        Self {
+            inner_size: cx.new_dynamic(attrs.inner_size.unwrap_or_default()),
+            location: cx.new_dynamic(attrs.location.unwrap_or_default()),
+            title: cx.new_dynamic(attrs.title),
+        }
+    }
+}
diff --git a/crates/gooey-kludgine/src/lib.rs b/crates/gooey-kludgine/src/lib.rs
index 0a00282ae..1f4ca03f2 100644
--- a/crates/gooey-kludgine/src/lib.rs
+++ b/crates/gooey-kludgine/src/lib.rs
@@ -1,24 +1,23 @@
 use std::fmt::Debug;
-use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
-use std::panic::UnwindSafe;
 use std::sync::Arc;
 
 use gooey_core::graphics::{Drawable, Options, TextMetrics};
 use gooey_core::math::units::UPx;
 use gooey_core::math::{IntoSigned, Point, Rect, ScreenUnit};
+use gooey_core::window::{NewWindow, Window, WindowAttributes, WindowLevel};
 use gooey_core::{Context, IntoNewWidget, NewWidget, Runtime, Widgets};
 use gooey_raster::{DrawableState, RasterContext, Rasterizable, RasterizedApp, Surface};
+use kludgine::app::winit::dpi::{PhysicalPosition, PhysicalSize};
 use kludgine::app::winit::event::ElementState;
-use kludgine::app::WindowBehavior;
+use kludgine::app::{winit, WindowBehavior};
 use kludgine::render::Drawing;
 use kludgine::shapes::Shape;
 use kludgine::text::TextOrigin;
 use kludgine::{Clipped, Color};
 
-pub fn run<Widget, Initializer>(widgets: Widgets<RasterizedApp<Kludgine>>, init: Initializer) -> !
+pub fn run<Widget>(widgets: Arc<Widgets<RasterizedApp<Kludgine>>>, init: NewWindow<Widget>) -> !
 where
-    Initializer: FnOnce(&Context) -> Widget + UnwindSafe + Send + 'static,
     Widget: gooey_core::Widget,
 {
     GooeyWindow::run_with((widgets, init))
@@ -113,17 +112,20 @@ where
 
 #[derive(Debug)]
 pub enum SurfaceEvent {
+    WindowTitleChanged,
+    WindowLocationChanged,
+    WindowSizeChanged,
     Invalidate,
     // InvalidateRect(Rect<UPx>),
 }
 
-struct GooeyWindow<Initializer, Widget> {
+struct GooeyWindow<Widget> {
     _root: NewWidget<Widget>,
     rasterizable: Rasterizable,
     context: RasterContext<Kludgine>,
     _runtime: Runtime,
     drawing: Drawing,
-    widget: PhantomData<Initializer>,
+    window: Window,
 }
 
 #[derive(Debug)]
@@ -134,28 +136,42 @@ impl gooey_raster::SurfaceHandle for Handle {
         let _result = self.0.send(SurfaceEvent::Invalidate);
     }
 
+    fn window_title_set(&self) {
+        let _result = self.0.send(SurfaceEvent::WindowTitleChanged);
+    }
+
+    fn window_position_set(&self) {
+        todo!()
+    }
+
+    fn window_size_set(&self) {
+        todo!()
+    }
     // fn invalidate_rect(&self, rect: Rect<UPx>) {
     //     let _result = self.0.send(SurfaceEvent::InvalidateRect(rect));
     // }
 }
 
-impl<Initializer, Widget> kludgine::app::WindowBehavior<SurfaceEvent>
-    for GooeyWindow<Initializer, Widget>
+impl<Widget> kludgine::app::WindowBehavior<SurfaceEvent> for GooeyWindow<Widget>
 where
-    Initializer: FnOnce(&Context) -> Widget + UnwindSafe + Send + 'static,
     Widget: gooey_core::Widget,
 {
-    type Context = (Widgets<RasterizedApp<Kludgine>>, Initializer);
+    type Context = (Arc<Widgets<RasterizedApp<Kludgine>>>, NewWindow<Widget>);
 
     fn initialize(
         window: kludgine::app::Window<'_, SurfaceEvent>,
         _graphics: &mut kludgine::Graphics<'_>,
-        (widgets, init): Self::Context,
+        (widgets, window_init): Self::Context,
     ) -> Self {
         let runtime = Runtime::default();
         let handle = Arc::new(Handle(window.handle()));
         let context = Context::root(RasterizedApp::<Kludgine>::new(handle.clone()), &runtime);
-        let root = init(&context).into_new(&context);
+        let running_window = Window {
+            inner_size: context.new_dynamic(window.inner_size()),
+            location: context.new_dynamic(window.location()),
+            title: context.new_dynamic(window.title()),
+        };
+        let root = (window_init.init)(&context, &running_window).into_new(&context);
         let context = RasterContext::new(widgets, (), handle);
         let rasterizable = context
             .widgets()
@@ -166,7 +182,11 @@ where
             move |_| handle.invalidate()
         });
 
-        // let root = app.instantiate(&root.widget, *root.style, &RasterContext);
+        running_window.title.for_each({
+            let handle = context.handle().clone();
+            move |_| handle.window_title_set()
+        });
+
         let drawing = Drawing::default();
         Self {
             _root: root,
@@ -174,7 +194,7 @@ where
             context,
             _runtime: runtime,
             drawing,
-            widget: PhantomData,
+            window: running_window,
         }
     }
 
@@ -194,6 +214,49 @@ where
         );
     }
 
+    fn initial_window_attributes(
+        context: &Self::Context,
+    ) -> kludgine::app::WindowAttributes<SurfaceEvent> {
+        let WindowAttributes {
+            inner_size,
+            location,
+            resizable,
+            title,
+            window_level,
+            ..
+            // min_inner_size,
+            // max_inner_size,
+            // enabled_buttons,
+            // maximized,
+            // visible,
+            // transparent,
+            // decorations,
+            // resize_increments,
+            // content_protected,
+            // active,
+        } = &context.1.attributes;
+
+        kludgine::app::WindowAttributes {
+            inner_size: inner_size.map(|inner_size| {
+                winit::dpi::Size::Physical(PhysicalSize::new(
+                    inner_size.width.0,
+                    inner_size.height.0,
+                ))
+            }),
+            location: location.map(|position| {
+                winit::dpi::Position::Physical(PhysicalPosition::new(position.x.0, position.y.0))
+            }),
+            resizable: *resizable,
+            window_level: match window_level {
+                WindowLevel::AlwaysOnBottom => winit::window::WindowLevel::AlwaysOnBottom,
+                WindowLevel::Normal => winit::window::WindowLevel::Normal,
+                WindowLevel::AlwaysOnTop => winit::window::WindowLevel::AlwaysOnTop,
+            },
+            title: title.clone(),
+            ..kludgine::app::WindowAttributes::default()
+        }
+    }
+
     fn render<'pass>(
         &'pass mut self,
         _window: kludgine::app::Window<'_, SurfaceEvent>,
@@ -208,16 +271,32 @@ where
     }
 
     fn event(&mut self, event: SurfaceEvent, mut window: kludgine::app::Window<'_, SurfaceEvent>) {
-        let SurfaceEvent::Invalidate = event;
-        window.set_needs_redraw();
+        match event {
+            SurfaceEvent::WindowTitleChanged => {
+                self.window.title.map_ref(|title| window.set_title(title));
+            }
+            SurfaceEvent::WindowLocationChanged => {
+                if let Some(location) = self.window.location.get() {
+                    window.set_location(location);
+                }
+            }
+            SurfaceEvent::WindowSizeChanged => {
+                if let Some(size) = self.window.inner_size.get() {
+                    window.set_inner_size(size);
+                }
+            }
+            SurfaceEvent::Invalidate => {
+                window.set_needs_redraw();
+            }
+        }
     }
 
     fn mouse_input(
         &mut self,
         window: kludgine::app::Window<'_, SurfaceEvent>,
-        _device_id: kludgine::app::winit::event::DeviceId,
+        _device_id: winit::event::DeviceId,
         state: ElementState,
-        _button: kludgine::app::winit::event::MouseButton,
+        _button: winit::event::MouseButton,
     ) {
         match state {
             ElementState::Pressed => self.rasterizable.mouse_down(
@@ -235,7 +314,7 @@ where
     fn cursor_left(
         &mut self,
         _window: kludgine::app::Window<'_, SurfaceEvent>,
-        _device_id: kludgine::app::winit::event::DeviceId,
+        _device_id: winit::event::DeviceId,
     ) {
         self.rasterizable.cursor_moved(None, &mut self.context);
     }
@@ -243,8 +322,8 @@ where
     fn cursor_moved(
         &mut self,
         window: kludgine::app::Window<'_, SurfaceEvent>,
-        _device_id: kludgine::app::winit::event::DeviceId,
-        position: kludgine::app::winit::dpi::PhysicalPosition<f64>,
+        _device_id: winit::event::DeviceId,
+        position: winit::dpi::PhysicalPosition<f64>,
     ) {
         let position = position.into();
         if Rect::from(window.inner_size())
diff --git a/crates/gooey-raster/src/lib.rs b/crates/gooey-raster/src/lib.rs
index e07277f04..868fba637 100644
--- a/crates/gooey-raster/src/lib.rs
+++ b/crates/gooey-raster/src/lib.rs
@@ -155,7 +155,7 @@ pub struct RasterContext<Surface>
 where
     Surface: crate::Surface,
 {
-    widgets: Widgets<RasterizedApp<Surface>>,
+    widgets: Arc<Widgets<RasterizedApp<Surface>>>,
     surface: Surface::Context,
     handle: Arc<dyn SurfaceHandle>,
 }
@@ -165,7 +165,7 @@ where
     Surface: crate::Surface,
 {
     pub fn new(
-        widgets: Widgets<RasterizedApp<Surface>>,
+        widgets: Arc<Widgets<RasterizedApp<Surface>>>,
         surface: Surface::Context,
         handle: Arc<dyn SurfaceHandle>,
     ) -> Self {
@@ -180,7 +180,7 @@ where
         &self.surface
     }
 
-    pub const fn widgets(&self) -> &Widgets<RasterizedApp<Surface>> {
+    pub fn widgets(&self) -> &Widgets<RasterizedApp<Surface>> {
         &self.widgets
     }
 
@@ -205,6 +205,18 @@ where
     fn invalidate(&self) {
         self.handle.invalidate()
     }
+
+    fn window_title_set(&self) {
+        self.handle.window_title_set()
+    }
+
+    fn window_position_set(&self) {
+        self.handle.window_position_set()
+    }
+
+    fn window_size_set(&self) {
+        self.handle.window_size_set()
+    }
 }
 
 impl<Surface> Debug for RasterContext<Surface>
@@ -250,6 +262,9 @@ where
 }
 
 pub trait SurfaceHandle: Debug + RefUnwindSafe + UnwindSafe + Sync + Send + 'static {
+    fn window_title_set(&self);
+    fn window_position_set(&self);
+    fn window_size_set(&self);
     fn invalidate(&self);
     // fn invalidate_rect(&self, rect: Rect<UPx>);
 }
diff --git a/examples/button.rs b/examples/button.rs
index e05231d09..5829b6126 100644
--- a/examples/button.rs
+++ b/examples/button.rs
@@ -1,7 +1,8 @@
+use gooey::App;
 use gooey_widgets::Button;
 
 fn main() {
-    gooey::run(gooey_widgets::widgets(), |cx| {
+    App::default().run(|cx, _window| {
         let counter = cx.new_dynamic(0i32);
         let label = counter.map_each(|count| count.to_string()).unwrap();
         Button::new(label).on_click(move |_| {
diff --git a/examples/counter.rs b/examples/counter.rs
index d79c26980..9c8c30e7c 100644
--- a/examples/counter.rs
+++ b/examples/counter.rs
@@ -1,8 +1,9 @@
+use gooey::App;
 use gooey_core::Children;
 use gooey_widgets::{Button, Flex, Label};
 
 fn main() {
-    gooey::run(gooey_widgets::widgets(), |cx| {
+    App::default().run(|cx, _window| {
         let counter = cx.new_dynamic(0i32);
         let label = counter.map_each(|count| count.to_string()).unwrap();
 
diff --git a/examples/counters.rs b/examples/counters.rs
index fdab34644..81049e8a2 100644
--- a/examples/counters.rs
+++ b/examples/counters.rs
@@ -1,8 +1,9 @@
+use gooey::App;
 use gooey_core::Children;
 use gooey_widgets::{Button, Flex};
 
 fn main() {
-    gooey::run(gooey_widgets::widgets(), |cx| {
+    App::default().run(|cx, _window| {
         let counters = cx.new_dynamic(Children::new(cx));
 
         Flex::rows(
diff --git a/src/lib.rs b/src/lib.rs
index fae97b7a6..bf709348e 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,32 +1,74 @@
+use core::window::{NewWindow, Window, WindowBuilder};
+use core::{Frontend, Widgets};
+use std::sync::Arc;
+
 use gooey_core::Context;
+#[cfg(feature = "raster")]
+pub use gooey_raster as raster;
+#[cfg(feature = "web")]
+pub use gooey_web as web;
+pub use {gooey_core as core, gooey_widgets as widgets};
 
-#[cfg(all(feature = "web", target_arch = "wasm32"))]
-pub fn run<Widget, Initializer>(
-    widgets: gooey_core::Widgets<gooey_web::WebApp>,
-    init: Initializer,
-) -> !
+pub struct App<A>
 where
-    Initializer: FnOnce(&Context) -> Widget,
-    Widget: gooey_core::Widget,
+    A: Frontend,
 {
-    gooey_web::attach_to_body(widgets, init);
+    widgets: Arc<gooey_core::Widgets<A>>,
+}
 
-    wasm_bindgen::throw_str("This is not an actual error. Please ignore.");
+#[cfg(all(feature = "web", target_arch = "wasm32"))]
+impl Default for App<gooey_web::WebApp> {
+    fn default() -> Self {
+        Self::new(gooey_widgets::widgets())
+    }
 }
+
 #[cfg(all(feature = "desktop", not(target_arch = "wasm32")))]
-pub fn run<Widget, Initializer>(
-    widgets: gooey_core::Widgets<gooey_raster::RasterizedApp<gooey_kludgine::Kludgine>>,
-    init: Initializer,
-) -> !
+impl Default for App<gooey_raster::RasterizedApp<gooey_kludgine::Kludgine>> {
+    fn default() -> Self {
+        Self::new(gooey_widgets::widgets())
+    }
+}
+
+impl<A> App<A>
 where
-    Initializer: FnOnce(&Context) -> Widget + std::panic::UnwindSafe + Send + 'static,
-    Widget: gooey_core::Widget,
+    A: Frontend,
 {
-    gooey_kludgine::run(widgets, init)
+    pub fn new(widgets: Widgets<A>) -> Self {
+        Self {
+            widgets: Arc::new(widgets),
+        }
+    }
 }
 
-#[cfg(feature = "raster")]
-pub use gooey_raster as raster;
-#[cfg(feature = "web")]
-pub use gooey_web as web;
-pub use {gooey_core as core, gooey_widgets as widgets};
+#[cfg(all(feature = "web", target_arch = "wasm32"))]
+impl App<gooey_raster::RasterizedApp<gooey_kludgine::Kludgine>> {
+    pub fn run<Widget, Initializer>(self, init: Initializer) -> !
+    where
+        Initializer: FnOnce(&Context, &Window) -> Widget + std::panic::UnwindSafe + Send + 'static,
+        Widget: gooey_core::Widget,
+    {
+        gooey_web::attach_to_body(widgets, init);
+
+        wasm_bindgen::throw_str("This is not an actual error. Please ignore.");
+    }
+}
+
+#[cfg(all(feature = "desktop", not(target_arch = "wasm32")))]
+impl App<gooey_raster::RasterizedApp<gooey_kludgine::Kludgine>> {
+    pub fn run_with<Widget, Initializer>(self, init: Initializer) -> !
+    where
+        Initializer: FnOnce(WindowBuilder) -> NewWindow<Widget>,
+        Widget: gooey_core::Widget,
+    {
+        gooey_kludgine::run(self.widgets, init(WindowBuilder::default()))
+    }
+
+    pub fn run<Widget, Initializer>(self, init: Initializer) -> !
+    where
+        Initializer: FnOnce(&Context, &Window) -> Widget + std::panic::UnwindSafe + Send + 'static,
+        Widget: gooey_core::Widget,
+    {
+        self.run_with(|builder| builder.create(init))
+    }
+}