8 files changed, 41 insertions, 29 deletions
diff --git a/native/src/element.rs b/native/src/element.rs
index 9b5adb9c..fab73f77 100644
--- a/native/src/element.rs
+++ b/native/src/element.rs
@@ -1,6 +1,5 @@
 use crate::{
-    layout, renderer, Clipboard, Color, Event, Hasher, Layout, Length, Point,
-    Widget,
+    layout, Clipboard, Color, Event, Hasher, Layout, Length, Point, Widget,
 };
 
 /// A generic [`Widget`].
@@ -195,7 +194,7 @@ where
     ) -> Element<'a, Message, Renderer>
     where
         Message: 'static,
-        Renderer: 'a + renderer::Debugger,
+        Renderer: 'a + layout::Debugger,
     {
         Element {
             widget: Box::new(Explain::new(self, color.into())),
@@ -348,7 +347,7 @@ where
 impl<'a, Message, Renderer> Widget<Message, Renderer>
     for Explain<'a, Message, Renderer>
 where
-    Renderer: crate::Renderer + renderer::Debugger,
+    Renderer: crate::Renderer + layout::Debugger,
 {
     fn width(&self) -> Length {
         self.element.widget.width()
diff --git a/native/src/layout.rs b/native/src/layout.rs
index e945706b..4a3ab94a 100644
--- a/native/src/layout.rs
+++ b/native/src/layout.rs
@@ -1,9 +1,11 @@
 //! Position your widgets properly.
+mod debugger;
 mod limits;
 mod node;
 
 pub mod flex;
 
+pub use debugger::Debugger;
 pub use limits::Limits;
 pub use node::Node;
 
diff --git a/native/src/renderer/debugger.rs b/native/src/layout/debugger.rs
index 30f3d9a0..e4b21609 100644
--- a/native/src/renderer/debugger.rs
+++ b/native/src/layout/debugger.rs
@@ -1,9 +1,9 @@
-use crate::{Color, Layout, Point, Widget};
+use crate::{Color, Layout, Point, Renderer, Widget};
 
 /// A renderer able to graphically explain a [`Layout`].
 ///
-/// [`Layout`]: ../struct.Layout.html
-pub trait Debugger: super::Renderer {
+/// [`Layout`]: struct.Layout.html
+pub trait Debugger: Renderer {
     /// Explains the [`Layout`] of an [`Element`] for debugging purposes.
     ///
     /// This will be called when [`Element::explain`] has been used. It should
@@ -13,8 +13,8 @@ pub trait Debugger: super::Renderer {
     /// [`Layout`] and its children.
     ///
     /// [`Layout`]: struct.Layout.html
-    /// [`Element`]: struct.Element.html
-    /// [`Element::explain`]: struct.Element.html#method.explain
+    /// [`Element`]: ../struct.Element.html
+    /// [`Element::explain`]: ../struct.Element.html#method.explain
     fn explain<Message>(
         &mut self,
         defaults: &Self::Defaults,
diff --git a/native/src/lib.rs b/native/src/lib.rs
index e65c6596..340b9ea7 100644
--- a/native/src/lib.rs
+++ b/native/src/lib.rs
@@ -14,7 +14,7 @@
 //! - A [`Widget`] trait, which is used to implement new widgets: from layout
 //!   requirements to event and drawing logic.
 //! - A bunch of `Renderer` traits, meant to keep the crate renderer-agnostic.
-//! - A [`Windowed`] trait, leveraging [`raw-window-handle`], which can be
+//! - A [`window::Renderer`] trait, leveraging [`raw-window-handle`], which can be
 //!   implemented by graphical renderers that target _windows_. Window-based
 //!   shells (like [`iced_winit`]) can use this trait to stay renderer-agnostic.
 //!
@@ -31,7 +31,7 @@
 //! [`druid`]: https://github.com/xi-editor/druid
 //! [`raw-window-handle`]: https://github.com/rust-windowing/raw-window-handle
 //! [`Widget`]: widget/trait.Widget.html
-//! [`Windowed`]: renderer/trait.Windowed.html
+//! [`window::Renderer`]: window/trait.Renderer.html
 //! [`UserInterface`]: struct.UserInterface.html
 //! [renderer]: renderer/index.html
 #![deny(missing_docs)]
diff --git a/native/src/renderer.rs b/native/src/renderer.rs
index 284c95f6..a16df72b 100644
--- a/native/src/renderer.rs
+++ b/native/src/renderer.rs
@@ -20,12 +20,6 @@
 //! [`Checkbox`]: ../widget/checkbox/struct.Checkbox.html
 //! [`checkbox::Renderer`]: ../widget/checkbox/trait.Renderer.html
 
-mod debugger;
-mod windowed;
-
-pub use debugger::Debugger;
-pub use windowed::{Target, Windowed};
-
 #[cfg(debug_assertions)]
 mod null;
 #[cfg(debug_assertions)]
@@ -58,7 +52,8 @@ pub trait Renderer: Sized {
     fn layout<'a, Message>(
         &mut self,
         element: &Element<'a, Message, Self>,
+        limits: &layout::Limits,
     ) -> layout::Node {
-        element.layout(self, &layout::Limits::NONE)
+        element.layout(self, limits)
     }
 }
diff --git a/native/src/user_interface.rs b/native/src/user_interface.rs
index 970bf0c1..85b25bc7 100644
--- a/native/src/user_interface.rs
+++ b/native/src/user_interface.rs
@@ -17,6 +17,7 @@ pub struct UserInterface<'a, Message, Renderer> {
     hash: u64,
     root: Element<'a, Message, Renderer>,
     layout: layout::Node,
+    bounds: Size,
     cursor_position: Point,
 }
 
@@ -39,7 +40,7 @@ where
     /// is naive way to set up our application loop:
     ///
     /// ```no_run
-    /// use iced_native::{UserInterface, Cache};
+    /// use iced_native::{UserInterface, Cache, Size};
     /// use iced_wgpu::Renderer;
     ///
     /// # mod iced_wgpu {
@@ -60,6 +61,7 @@ where
     /// let mut counter = Counter::new();
     /// let mut cache = Cache::new();
     /// let mut renderer = Renderer::new();
+    /// let mut window_size = Size::new(1024.0, 768.0);
     ///
     /// // Application loop
     /// loop {
@@ -68,6 +70,7 @@ where
     ///     // Build the user interface
     ///     let user_interface = UserInterface::build(
     ///         counter.view(),
+    ///         window_size,
     ///         cache,
     ///         &mut renderer,
     ///     );
@@ -81,26 +84,30 @@ where
     /// ```
     pub fn build<E: Into<Element<'a, Message, Renderer>>>(
         root: E,
+        bounds: Size,
         cache: Cache,
         renderer: &mut Renderer,
     ) -> Self {
         let root = root.into();
 
-        let hasher = &mut crate::Hasher::default();
-        root.hash_layout(hasher);
+        let hash = {
+            let hasher = &mut crate::Hasher::default();
+            root.hash_layout(hasher);
 
-        let hash = hasher.finish();
+            hasher.finish()
+        };
 
-        let layout = if hash == cache.hash {
+        let layout = if hash == cache.hash && bounds == cache.bounds {
             cache.layout
         } else {
-            renderer.layout(&root)
+            renderer.layout(&root, &layout::Limits::new(Size::ZERO, bounds))
         };
 
         UserInterface {
             hash,
             root,
             layout,
+            bounds,
             cursor_position: cache.cursor_position,
         }
     }
@@ -118,7 +125,7 @@ where
     /// completing [the previous example](#example):
     ///
     /// ```no_run
-    /// use iced_native::{UserInterface, Cache};
+    /// use iced_native::{UserInterface, Cache, Size};
     /// use iced_wgpu::Renderer;
     ///
     /// # mod iced_wgpu {
@@ -139,6 +146,7 @@ where
     /// let mut counter = Counter::new();
     /// let mut cache = Cache::new();
     /// let mut renderer = Renderer::new();
+    /// let mut window_size = Size::new(1024.0, 768.0);
     ///
     /// // Initialize our event storage
     /// let mut events = Vec::new();
@@ -148,6 +156,7 @@ where
     ///
     ///     let mut user_interface = UserInterface::build(
     ///         counter.view(),
+    ///         window_size,
     ///         cache,
     ///         &mut renderer,
     ///     );
@@ -203,7 +212,7 @@ where
     /// [completing the last example](#example-1):
     ///
     /// ```no_run
-    /// use iced_native::{UserInterface, Cache};
+    /// use iced_native::{UserInterface, Cache, Size};
     /// use iced_wgpu::Renderer;
     ///
     /// # mod iced_wgpu {
@@ -224,6 +233,7 @@ where
     /// let mut counter = Counter::new();
     /// let mut cache = Cache::new();
     /// let mut renderer = Renderer::new();
+    /// let mut window_size = Size::new(1024.0, 768.0);
     /// let mut events = Vec::new();
     ///
     /// loop {
@@ -231,6 +241,7 @@ where
     ///
     ///     let mut user_interface = UserInterface::build(
     ///         counter.view(),
+    ///         window_size,
     ///         cache,
     ///         &mut renderer,
     ///     );
@@ -268,6 +279,7 @@ where
         Cache {
             hash: self.hash,
             layout: self.layout,
+            bounds: self.bounds,
             cursor_position: self.cursor_position,
         }
     }
@@ -280,6 +292,7 @@ where
 pub struct Cache {
     hash: u64,
     layout: layout::Node,
+    bounds: Size,
     cursor_position: Point,
 }
 
@@ -295,6 +308,7 @@ impl Cache {
         Cache {
             hash: 0,
             layout: layout::Node::new(Size::new(0.0, 0.0)),
+            bounds: Size::ZERO,
             cursor_position: Point::new(-1.0, -1.0),
         }
     }
diff --git a/native/src/window.rs b/native/src/window.rs
index 220bb3be..db9226dc 100644
--- a/native/src/window.rs
+++ b/native/src/window.rs
@@ -1,4 +1,6 @@
 //! Build window-based GUI applications.
 mod event;
+mod renderer;
 
 pub use event::Event;
+pub use renderer::{Renderer, Target};
diff --git a/native/src/renderer/windowed.rs b/native/src/window/renderer.rs
index ee020ab1..be9765fa 100644
--- a/native/src/renderer/windowed.rs
+++ b/native/src/window/renderer.rs
@@ -3,16 +3,16 @@ use crate::MouseCursor;
 use raw_window_handle::HasRawWindowHandle;
 
 /// A renderer that can target windows.
-pub trait Windowed: super::Renderer + Sized {
+pub trait Renderer: crate::Renderer + Sized {
     /// The settings of the renderer.
     type Settings: Default;
 
     /// The type of target.
     type Target: Target<Renderer = Self>;
 
-    /// Creates a new [`Windowed`] renderer.
+    /// Creates a new window [`Renderer`].
     ///
-    /// [`Windowed`]: trait.Windowed.html
+    /// [`Renderer`]: trait.Renderer.html
     fn new(settings: Self::Settings) -> Self;
 
     /// Performs the drawing operations described in the output on the given