diff --git a/src/app_handle.rs b/src/app_handle.rs
index 6b1b9790..391d5872 100644
--- a/src/app_handle.rs
+++ b/src/app_handle.rs
@@ -159,7 +159,7 @@ impl ApplicationHandle {
                 window_handle.menu_action(id);
             }
             WindowEvent::RedrawRequested => {
-                window_handle.paint();
+                window_handle.render_frame();
             }
         }
     }
diff --git a/src/context.rs b/src/context.rs
index d06f7333..dc016ba8 100644
--- a/src/context.rs
+++ b/src/context.rs
@@ -6,12 +6,9 @@ use std::{
     time::{Duration, Instant},
 };
 
-use floem_renderer::{
-    cosmic_text::{LineHeightValue, Style as FontStyle, Weight},
-    Renderer as FloemRenderer,
-};
+use bitflags::bitflags;
+use floem_renderer::Renderer as FloemRenderer;
 use kurbo::{Affine, Insets, Point, Rect, RoundedRect, Shape, Size, Vec2};
-use peniko::Color;
 use taffy::{
     prelude::{Layout, Node},
     style::{AvailableSpace, Display},
@@ -34,7 +31,7 @@ use crate::{
         StyleSelector, StyleSelectors, ZIndex,
     },
     unit::PxPct,
-    view::{paint_bg, paint_border, paint_outline, ChangeFlags, View},
+    view::{paint_bg, paint_border, paint_outline, View},
 };
 
 pub type EventCallback = dyn Fn(&Event) -> bool;
@@ -65,11 +62,19 @@ prop_extracter! {
     }
 }
 
+bitflags! {
+    #[derive(Default, Copy, Clone, Debug)]
+    #[must_use]
+    pub(crate) struct ChangeFlags: u8 {
+        const STYLE = 1;
+        const LAYOUT = 1 << 1;
+    }
+}
+
 pub struct ViewState {
     pub(crate) node: Node,
     pub(crate) children_nodes: Vec<Node>,
-    pub(crate) request_layout: bool,
-    pub(crate) request_style: bool,
+    pub(crate) requested_changes: ChangeFlags,
     /// Layout is requested on all direct and indirect children.
     pub(crate) request_style_recursive: bool,
     pub(crate) has_style_selectors: StyleSelectors,
@@ -101,8 +106,7 @@ impl ViewState {
             layout_rect: Rect::ZERO,
             layout_props: Default::default(),
             view_style_props: Default::default(),
-            request_layout: true,
-            request_style: true,
+            requested_changes: ChangeFlags::all(),
             request_style_recursive: false,
             has_style_selectors: StyleSelectors::default(),
             animation: None,
@@ -123,6 +127,7 @@ impl ViewState {
         }
     }
 
+    /// Returns `true` if a new frame is requested.
     pub(crate) fn compute_style(
         &mut self,
         view_style: Option<Style>,
@@ -131,7 +136,8 @@ impl ViewState {
         view_class: Option<StyleClassRef>,
         classes: &[StyleClassRef],
         context: &Style,
-    ) {
+    ) -> bool {
+        let mut new_frame = false;
         let mut computed_style = Style::new();
         if let Some(view_style) = view_style {
             computed_style.apply_mut(view_style);
@@ -152,6 +158,8 @@ impl ViewState {
                     break 'anim;
                 }
 
+                new_frame = true;
+
                 let props = animation.props();
 
                 for kind in props.keys() {
@@ -183,6 +191,8 @@ impl ViewState {
         computed_style.apply_interact_state(&interact_state, screen_size_bp);
 
         self.combined_style = computed_style;
+
+        new_frame
     }
 }
 
@@ -192,6 +202,12 @@ pub struct DragState {
     pub(crate) released_at: Option<std::time::Instant>,
 }
 
+pub(crate) enum FrameUpdate {
+    Style(Id),
+    Layout(Id),
+    Paint(Id),
+}
+
 /// Encapsulates and owns the global state of the application,
 /// including the `ViewState` of each view.
 pub struct AppState {
@@ -206,6 +222,8 @@ pub struct AppState {
     pub taffy: taffy::Taffy,
     pub(crate) view_states: HashMap<Id, ViewState>,
     stale_view_state: ViewState,
+    pub(crate) scheduled_updates: Vec<FrameUpdate>,
+    pub(crate) request_paint: bool,
     pub(crate) disabled: HashSet<Id>,
     pub(crate) keyboard_navigable: HashSet<Id>,
     pub(crate) draggable: HashSet<Id>,
@@ -218,9 +236,6 @@ pub struct AppState {
     pub(crate) hovered: HashSet<Id>,
     /// This keeps track of all views that have an animation,
     /// regardless of the status of the animation
-    pub(crate) animated: HashSet<Id>,
-    /// This is a set of view which have active transition animations.
-    pub(crate) transitioning: HashSet<Id>,
     pub(crate) cursor: Option<CursorStyle>,
     pub(crate) last_cursor: CursorIcon,
     pub(crate) keyboard_navigation: bool,
@@ -251,8 +266,8 @@ impl AppState {
             stale_view_state: ViewState::new(&mut taffy),
             taffy,
             view_states: HashMap::new(),
-            animated: HashSet::new(),
-            transitioning: HashSet::new(),
+            scheduled_updates: Vec::new(),
+            request_paint: false,
             disabled: HashSet::new(),
             keyboard_navigable: HashSet::new(),
             draggable: HashSet::new(),
@@ -308,8 +323,6 @@ impl AppState {
         self.dragging_over.remove(&id);
         self.clicking.remove(&id);
         self.hovered.remove(&id);
-        self.animated.remove(&id);
-        self.transitioning.remove(&id);
         self.clicking.remove(&id);
         if self.focus == Some(id) {
             self.focus = None;
@@ -319,20 +332,6 @@ impl AppState {
         }
     }
 
-    pub fn ids_with_anim_in_progress(&mut self) -> Vec<Id> {
-        self.animated
-            .clone()
-            .into_iter()
-            .filter(|id| {
-                let anim = &self.view_state(*id).animation;
-                if let Some(anim) = anim {
-                    return !anim.is_completed();
-                }
-                false
-            })
-            .collect()
-    }
-
     pub fn is_hidden(&self, id: Id) -> bool {
         self.view_states
             .get(&id)
@@ -402,7 +401,7 @@ impl AppState {
         view_class: Option<StyleClassRef>,
         classes: &[StyleClassRef],
         context: &Style,
-    ) {
+    ) -> bool {
         let interact_state = self.get_interact_state(&id);
         let screen_size_bp = self.screen_size_bp;
         let view_state = self.view_state(id);
@@ -413,7 +412,7 @@ impl AppState {
             view_class,
             classes,
             context,
-        );
+        )
     }
 
     pub(crate) fn get_computed_style(&mut self, id: Id) -> &Style {
@@ -444,34 +443,53 @@ impl AppState {
         self.request_style(id);
     }
 
-    pub fn request_style(&mut self, id: Id) {
+    /// Request that this the `id` view be styled, laid out and painted again.
+    /// This will recursively request this for all parents.
+    pub fn request_all(&mut self, id: Id) {
+        self.request_changes(id, ChangeFlags::all());
+        self.request_paint(id);
+    }
+
+    pub(crate) fn request_changes(&mut self, id: Id, flags: ChangeFlags) {
         let view = self.view_state(id);
-        if view.request_style {
+        if view.requested_changes.contains(flags) {
             return;
         }
-        view.request_style = true;
+        view.requested_changes.insert(flags);
         if let Some(parent) = id.parent() {
-            self.request_style(parent);
+            self.request_changes(parent, flags);
         }
     }
 
+    /// Requests that the style pass will run for `id` on the next frame, and ensures new frame is
+    /// scheduled to happen.
+    pub fn schedule_style(&mut self, id: Id) {
+        self.scheduled_updates.push(FrameUpdate::Style(id));
+    }
+
+    /// Requests that the layout pass will run for `id` on the next frame, and ensures new frame is
+    /// scheduled to happen.
+    pub fn schedule_layout(&mut self, id: Id) {
+        self.scheduled_updates.push(FrameUpdate::Layout(id));
+    }
+
+    /// Requests that the paint pass will run for `id` on the next frame, and ensures new frame is
+    /// scheduled to happen.
+    pub fn schedule_paint(&mut self, id: Id) {
+        self.scheduled_updates.push(FrameUpdate::Paint(id));
+    }
+
+    pub fn request_style(&mut self, id: Id) {
+        self.request_changes(id, ChangeFlags::STYLE)
+    }
+
     pub fn request_layout(&mut self, id: Id) {
-        let view = self.view_state(id);
-        if view.request_layout {
-            return;
-        }
-        view.request_layout = true;
-        if let Some(parent) = id.parent() {
-            self.request_layout(parent);
-        }
+        self.request_changes(id, ChangeFlags::LAYOUT)
     }
 
-    pub fn request_paint(&mut self, id: Id) {
-        // Painting currently happens on any change, so request styling on the root
-        // view.
-        if let Some(id) = id.id_path().and_then(|path| path.0.get(1).copied()) {
-            self.request_style(id)
-        }
+    // `Id` is unused currently, but could be used to calculate damage regions.
+    pub fn request_paint(&mut self, _id: Id) {
+        self.request_paint = true;
     }
 
     pub(crate) fn set_viewport(&mut self, id: Id, viewport: Rect) {
@@ -652,11 +670,18 @@ impl<'a> EventCx<'a> {
     }
 
     /// request that this node be painted again
-    /// This will recursively request painting for all parents
     pub fn request_paint(&mut self, id: Id) {
         self.app_state.request_paint(id);
     }
 
+    pub fn app_state_mut(&mut self) -> &mut AppState {
+        self.app_state
+    }
+
+    pub fn app_state(&self) -> &AppState {
+        self.app_state
+    }
+
     pub fn update_active(&mut self, id: Id) {
         self.app_state.update_active(id);
     }
@@ -1102,10 +1127,10 @@ impl<'a> StyleCx<'a> {
         self.save();
         let id = view.id();
         let view_state = self.app_state_mut().view_state(id);
-        if !view_state.request_style {
+        if !view_state.requested_changes.contains(ChangeFlags::STYLE) {
             return;
         }
-        view_state.request_style = false;
+        view_state.requested_changes.remove(ChangeFlags::STYLE);
 
         let view_style = view.view_style();
         let view_class = view.view_class();
@@ -1124,13 +1149,15 @@ impl<'a> StyleCx<'a> {
             view.for_each_child(&mut |child| {
                 let state = self.app_state_mut().view_state(child.id());
                 state.request_style_recursive = true;
-                state.request_style = true;
+                state.requested_changes.insert(ChangeFlags::STYLE);
                 false
             });
         }
 
-        self.app_state
-            .compute_style(id, view_style, view_class, classes, &self.current);
+        let mut new_frame =
+            self.app_state
+                .compute_style(id, view_style, view_class, classes, &self.current);
+
         let style = self.app_state_mut().get_computed_style(id).clone();
         self.direct = style;
         Style::apply_only_inherited(&mut self.current, &self.direct);
@@ -1149,25 +1176,23 @@ impl<'a> StyleCx<'a> {
 
         let view_state = self.app_state.view_state(id);
 
-        let mut transition = false;
-
         // Extract the relevant layout properties so the content rect can be calculated
         // when painting.
         view_state.layout_props.read_explicit(
             &self.direct,
             &self.current,
             &self.now,
-            &mut transition,
+            &mut new_frame,
         );
 
         view_state.view_style_props.read_explicit(
             &self.direct,
             &self.current,
             &self.now,
-            &mut transition,
+            &mut new_frame,
         );
-        if transition {
-            self.request_transition();
+        if new_frame {
+            self.app_state.schedule_style(id);
         }
 
         view.style(self);
@@ -1193,9 +1218,9 @@ impl<'a> StyleCx<'a> {
         (*self.current).clone().apply(self.direct.clone())
     }
 
-    pub(crate) fn request_transition(&mut self) {
+    pub fn request_transition(&mut self) {
         let id = self.current_view;
-        self.app_state_mut().transitioning.insert(id);
+        self.app_state_mut().schedule_style(id);
     }
 
     pub fn app_state_mut(&mut self) -> &mut AppState {
@@ -1293,10 +1318,10 @@ impl<'a> LayoutCx<'a> {
     ) -> Node {
         let view_state = self.app_state.view_state(id);
         let node = view_state.node;
-        if !view_state.request_layout {
+        if !view_state.requested_changes.contains(ChangeFlags::LAYOUT) {
             return node;
         }
-        view_state.request_layout = false;
+        view_state.requested_changes.remove(ChangeFlags::LAYOUT);
         let style = view_state.combined_style.to_taffy_style();
         let _ = self.app_state.taffy.set_style(node, style);
 
@@ -1422,27 +1447,9 @@ pub struct PaintCx<'a> {
     pub(crate) paint_state: &'a mut PaintState,
     pub(crate) transform: Affine,
     pub(crate) clip: Option<RoundedRect>,
-    pub(crate) color: Option<Color>,
-    pub(crate) scroll_bar_rounded: Option<bool>,
-    pub(crate) scroll_bar_thickness: Option<f32>,
-    pub(crate) scroll_bar_edge_width: Option<f32>,
-    pub(crate) font_size: Option<f32>,
-    pub(crate) font_family: Option<String>,
-    pub(crate) font_weight: Option<Weight>,
-    pub(crate) font_style: Option<FontStyle>,
-    pub(crate) line_height: Option<LineHeightValue>,
     pub(crate) z_index: Option<i32>,
     pub(crate) saved_transforms: Vec<Affine>,
     pub(crate) saved_clips: Vec<Option<RoundedRect>>,
-    pub(crate) saved_colors: Vec<Option<Color>>,
-    pub(crate) saved_scroll_bar_roundeds: Vec<Option<bool>>,
-    pub(crate) saved_scroll_bar_thicknesses: Vec<Option<f32>>,
-    pub(crate) saved_scroll_bar_edge_widths: Vec<Option<f32>>,
-    pub(crate) saved_font_sizes: Vec<Option<f32>>,
-    pub(crate) saved_font_families: Vec<Option<String>>,
-    pub(crate) saved_font_weights: Vec<Option<Weight>>,
-    pub(crate) saved_font_styles: Vec<Option<FontStyle>>,
-    pub(crate) saved_line_heights: Vec<Option<LineHeightValue>>,
     pub(crate) saved_z_indexes: Vec<Option<i32>>,
 }
 
@@ -1450,32 +1457,12 @@ impl<'a> PaintCx<'a> {
     pub fn save(&mut self) {
         self.saved_transforms.push(self.transform);
         self.saved_clips.push(self.clip);
-        self.saved_colors.push(self.color);
-        self.saved_scroll_bar_roundeds.push(self.scroll_bar_rounded);
-        self.saved_scroll_bar_thicknesses
-            .push(self.scroll_bar_thickness);
-        self.saved_scroll_bar_edge_widths
-            .push(self.scroll_bar_edge_width);
-        self.saved_font_sizes.push(self.font_size);
-        self.saved_font_families.push(self.font_family.clone());
-        self.saved_font_weights.push(self.font_weight);
-        self.saved_font_styles.push(self.font_style);
-        self.saved_line_heights.push(self.line_height);
         self.saved_z_indexes.push(self.z_index);
     }
 
     pub fn restore(&mut self) {
         self.transform = self.saved_transforms.pop().unwrap_or_default();
         self.clip = self.saved_clips.pop().unwrap_or_default();
-        self.color = self.saved_colors.pop().unwrap_or_default();
-        self.scroll_bar_rounded = self.saved_scroll_bar_roundeds.pop().unwrap_or_default();
-        self.scroll_bar_thickness = self.saved_scroll_bar_thicknesses.pop().unwrap_or_default();
-        self.scroll_bar_edge_width = self.saved_scroll_bar_edge_widths.pop().unwrap_or_default();
-        self.font_size = self.saved_font_sizes.pop().unwrap_or_default();
-        self.font_family = self.saved_font_families.pop().unwrap_or_default();
-        self.font_weight = self.saved_font_weights.pop().unwrap_or_default();
-        self.font_style = self.saved_font_styles.pop().unwrap_or_default();
-        self.line_height = self.saved_line_heights.pop().unwrap_or_default();
         self.z_index = self.saved_z_indexes.pop().unwrap_or_default();
         self.paint_state.renderer.transform(self.transform);
         if let Some(z_index) = self.z_index {
@@ -1580,30 +1567,6 @@ impl<'a> PaintCx<'a> {
         self.restore();
     }
 
-    pub fn current_color(&self) -> Option<Color> {
-        self.color
-    }
-
-    pub fn current_scroll_bar_rounded(&self) -> Option<bool> {
-        self.scroll_bar_rounded
-    }
-
-    pub fn current_scroll_bar_thickness(&self) -> Option<f32> {
-        self.scroll_bar_thickness
-    }
-
-    pub fn current_scroll_bar_edge_width(&self) -> Option<f32> {
-        self.scroll_bar_edge_width
-    }
-
-    pub fn current_font_size(&self) -> Option<f32> {
-        self.font_size
-    }
-
-    pub fn current_font_family(&self) -> Option<&str> {
-        self.font_family.as_deref()
-    }
-
     pub fn layout(&self, node: Node) -> Option<Layout> {
         self.app_state.taffy.layout(node).ok().copied()
     }
@@ -1727,8 +1690,7 @@ impl<'a> UpdateCx<'a> {
     /// request that this node be styled, laid out and painted again
     /// This will recursively request this for all parents.
     pub fn request_all(&mut self, id: Id) {
-        self.app_state.request_style(id);
-        self.app_state.request_layout(id);
+        self.app_state.request_all(id);
     }
 
     /// request that this node be styled again
@@ -1743,24 +1705,26 @@ impl<'a> UpdateCx<'a> {
         self.app_state.request_layout(id);
     }
 
+    pub fn app_state_mut(&mut self) -> &mut AppState {
+        self.app_state
+    }
+
+    pub fn app_state(&self) -> &AppState {
+        self.app_state
+    }
+
     /// Used internally by Floem to send an update to the correct view based on the `Id` path.
     /// It will invoke only once `update` when the correct view is located.
-    pub fn update_view(
-        &mut self,
-        view: &mut dyn View,
-        id_path: &[Id],
-        state: Box<dyn Any>,
-    ) -> ChangeFlags {
+    pub fn update_view(&mut self, view: &mut dyn View, id_path: &[Id], state: Box<dyn Any>) {
         let id = id_path[0];
         let id_path = &id_path[1..];
         if id == view.id() {
             if id_path.is_empty() {
-                return view.update(self, state);
+                view.update(self, state);
             } else if let Some(child) = view.child_mut(id_path[0]) {
-                return self.update_view(child, id_path, state);
+                self.update_view(child, id_path, state);
             }
         }
-        ChangeFlags::empty()
     }
 }
 
diff --git a/src/id.rs b/src/id.rs
index e8c6492e..98afe18a 100644
--- a/src/id.rs
+++ b/src/id.rs
@@ -14,11 +14,10 @@ use kurbo::Point;
 
 use crate::{
     animate::Animation,
-    context::{EventCallback, MenuCallback, ResizeCallback},
+    context::{ChangeFlags, EventCallback, MenuCallback, ResizeCallback},
     event::EventListener,
     style::{Style, StyleClassRef, StyleSelector},
     update::{UpdateMessage, CENTRAL_DEFERRED_UPDATE_MESSAGES, CENTRAL_UPDATE_MESSAGES},
-    view::ChangeFlags,
 };
 
 thread_local! {
@@ -126,16 +125,15 @@ impl Id {
         });
     }
 
-    pub fn request_change(&self, flags: ChangeFlags) {
-        self.add_update_message(UpdateMessage::RequestChange { id: *self, flags });
-    }
-
     pub fn request_paint(&self) {
         self.add_update_message(UpdateMessage::RequestPaint);
     }
 
     pub fn request_layout(&self) {
-        self.add_update_message(UpdateMessage::RequestLayout { id: *self });
+        self.add_update_message(UpdateMessage::RequestChange {
+            id: *self,
+            flags: ChangeFlags::LAYOUT,
+        });
     }
 
     pub fn update_state(&self, state: impl Any, deferred: bool) {
diff --git a/src/inspector.rs b/src/inspector.rs
index f38fbbe8..51c6e2b0 100644
--- a/src/inspector.rs
+++ b/src/inspector.rs
@@ -1,5 +1,5 @@
 use crate::app::{add_app_update_event, AppUpdateEvent};
-use crate::context::{AppState, StyleCx};
+use crate::context::{AppState, ChangeFlags, StyleCx};
 use crate::event::{Event, EventListener};
 use crate::id::Id;
 use crate::style::{Style, StyleMapValue};
@@ -32,8 +32,7 @@ pub struct CapturedView {
     clipped: Rect,
     children: Vec<Rc<CapturedView>>,
     direct_style: Style,
-    request_style: bool,
-    request_layout: bool,
+    requested_changes: ChangeFlags,
 }
 
 impl CapturedView {
@@ -52,8 +51,7 @@ impl CapturedView {
             taffy,
             clipped,
             direct_style: computed_style,
-            request_style: state.request_style,
-            request_layout: state.request_layout,
+            requested_changes: state.requested_changes,
             children: view_children(view)
                 .into_iter()
                 .map(|view| Rc::new(CapturedView::capture(view, app_state, clipped)))
@@ -80,9 +78,7 @@ impl CapturedView {
     }
 
     fn warnings(&self) -> bool {
-        self.request_layout
-            || self.request_style
-            || self.children.iter().any(|child| child.warnings())
+        !self.requested_changes.is_empty() || self.children.iter().any(|child| child.warnings())
     }
 }
 
diff --git a/src/update.rs b/src/update.rs
index 88f650c6..45767976 100644
--- a/src/update.rs
+++ b/src/update.rs
@@ -5,12 +5,11 @@ use winit::window::ResizeDirection;
 
 use crate::{
     animate::{AnimUpdateMsg, Animation},
-    context::{EventCallback, ResizeCallback},
+    context::{ChangeFlags, EventCallback, ResizeCallback},
     event::EventListener,
     id::Id,
     menu::Menu,
     style::{Style, StyleClassRef, StyleSelector},
-    view::ChangeFlags,
 };
 
 thread_local! {
@@ -42,9 +41,6 @@ pub(crate) enum UpdateMessage {
         flags: ChangeFlags,
     },
     RequestPaint,
-    RequestLayout {
-        id: Id,
-    },
     State {
         id: Id,
         state: Box<dyn Any>,
diff --git a/src/view.rs b/src/view.rs
index 81463a68..bf94a112 100644
--- a/src/view.rs
+++ b/src/view.rs
@@ -83,7 +83,6 @@
 //!
 //!
 
-use bitflags::bitflags;
 use floem_renderer::Renderer;
 use kurbo::{Circle, Insets, Line, Point, Rect, RoundedRect, Size};
 use std::any::Any;
@@ -96,18 +95,6 @@ use crate::{
     style::{BoxShadowProp, Outline, OutlineColor, Style, StyleClassRef},
 };
 
-bitflags! {
-    #[derive(Default, Copy, Clone)]
-    #[must_use]
-    pub struct ChangeFlags: u8 {
-        const UPDATE = 1;
-        const STYLE = 1 << 1;
-        const LAYOUT = 1 << 2;
-        const ACCESSIBILITY = 1 << 3;
-        const PAINT = 1 << 4;
-    }
-}
-
 pub trait View {
     fn id(&self) -> Id;
 
@@ -172,13 +159,16 @@ pub trait View {
     /// self.id.update_state(SomeState)
     /// ```
     ///
-    /// You are in charge of downcasting the state to the expected type and you're required to return
-    /// indicating if you'd like a layout or paint pass to be scheduled.
-    fn update(&mut self, _cx: &mut UpdateCx, _state: Box<dyn Any>) -> ChangeFlags {
-        ChangeFlags::empty()
-    }
+    /// You are in charge of downcasting the state to the expected type.
+    ///
+    /// If the update needs other passes to run you're expected to call
+    /// `_cx.app_state_mut().request_changes`.
+    fn update(&mut self, _cx: &mut UpdateCx, _state: Box<dyn Any>) {}
 
     /// Use this method to style the view's children.
+    ///
+    /// If the style changes needs other passes to run you're expected to call
+    /// `cx.app_state_mut().request_changes`.
     fn style(&mut self, cx: &mut StyleCx<'_>) {
         self.for_each_child_mut(&mut |child| {
             cx.style_view(child);
@@ -187,7 +177,10 @@ pub trait View {
     }
 
     /// Use this method to layout the view's children.
-    /// Usually you'll do this by calling `LayoutCx::layout_node`
+    /// Usually you'll do this by calling `LayoutCx::layout_node`.
+    ///
+    /// If the layout changes needs other passes to run you're expected to call
+    /// `cx.app_state_mut().request_changes`.
     fn layout(&mut self, cx: &mut LayoutCx) -> Node {
         cx.layout_node(self.id(), true, |cx| {
             let mut nodes = Vec::new();
@@ -200,6 +193,9 @@ pub trait View {
     }
 
     /// Responsible for computing the layout of the view's children.
+    ///
+    /// If the layout changes needs other passes to run you're expected to call
+    /// `cx.app_state_mut().request_changes`.
     fn compute_layout(&mut self, cx: &mut LayoutCx) -> Option<Rect> {
         default_compute_layout(self, cx)
     }
@@ -207,6 +203,9 @@ pub trait View {
     /// Implement this to handle events and to pass them down to children
     ///
     /// Return true to stop the event from propagating to other views
+    ///
+    /// If the event needs other passes to run you're expected to call
+    /// `cx.app_state_mut().request_changes`.
     fn event(&mut self, cx: &mut EventCx, id_path: Option<&[Id]>, event: Event) -> bool {
         let mut handled = false;
         self.for_each_child_rev_mut(&mut |child| {
@@ -622,7 +621,7 @@ impl View for Box<dyn View> {
         (**self).debug_name()
     }
 
-    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn Any>) -> ChangeFlags {
+    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn Any>) {
         (**self).update(cx, state)
     }
 
diff --git a/src/views/dyn_container.rs b/src/views/dyn_container.rs
index 2b9e0859..818a00c1 100644
--- a/src/views/dyn_container.rs
+++ b/src/views/dyn_container.rs
@@ -2,7 +2,7 @@ use floem_reactive::{as_child_of_current_scope, create_effect, Scope};
 
 use crate::{
     id::Id,
-    view::{view_children_set_parent_id, ChangeFlags, View},
+    view::{view_children_set_parent_id, View},
 };
 
 type ChildFn<T> = dyn Fn(T) -> (Box<dyn View>, Scope);
@@ -111,11 +111,7 @@ impl<T: 'static> View for DynamicContainer<T> {
         "DynamicContainer".into()
     }
 
-    fn update(
-        &mut self,
-        cx: &mut crate::context::UpdateCx,
-        state: Box<dyn std::any::Any>,
-    ) -> crate::view::ChangeFlags {
+    fn update(&mut self, cx: &mut crate::context::UpdateCx, state: Box<dyn std::any::Any>) {
         if let Ok(val) = state.downcast::<T>() {
             let old_child_scope = self.child_scope;
             (self.child, self.child_scope) = (self.child_fn)(*val);
@@ -123,9 +119,6 @@ impl<T: 'static> View for DynamicContainer<T> {
             self.child.id().set_parent(self.id);
             view_children_set_parent_id(&*self.child);
             cx.request_all(self.id());
-            ChangeFlags::all()
-        } else {
-            ChangeFlags::empty()
         }
     }
 }
diff --git a/src/views/img.rs b/src/views/img.rs
index 1420cdea..7ef173bc 100644
--- a/src/views/img.rs
+++ b/src/views/img.rs
@@ -5,12 +5,7 @@ use floem_renderer::Renderer;
 use image::{DynamicImage, GenericImageView};
 use sha2::{Digest, Sha256};
 
-use crate::{
-    id::Id,
-    style::Style,
-    unit::UnitExt,
-    view::{ChangeFlags, View},
-};
+use crate::{id::Id, style::Style, unit::UnitExt, view::View};
 
 use taffy::prelude::Node;
 
@@ -121,11 +116,7 @@ impl View for Img {
         "Img".into()
     }
 
-    fn update(
-        &mut self,
-        cx: &mut crate::context::UpdateCx,
-        state: Box<dyn std::any::Any>,
-    ) -> crate::view::ChangeFlags {
+    fn update(&mut self, cx: &mut crate::context::UpdateCx, state: Box<dyn std::any::Any>) {
         if let Ok(img) = state.downcast::<Option<Rc<DynamicImage>>>() {
             self.img_hash = (*img).as_ref().map(|img| {
                 let mut hasher = Sha256::new();
@@ -135,9 +126,6 @@ impl View for Img {
             self.img = *img;
             self.img_dimensions = self.img.as_ref().map(|img| img.dimensions());
             cx.request_layout(self.id());
-            ChangeFlags::LAYOUT
-        } else {
-            ChangeFlags::empty()
         }
     }
 
diff --git a/src/views/label.rs b/src/views/label.rs
index ee20e45f..f6b4f022 100644
--- a/src/views/label.rs
+++ b/src/views/label.rs
@@ -8,7 +8,7 @@ use crate::{
     style::Style,
     style::{FontProps, LineHeight, TextColor, TextOverflow, TextOverflowProp},
     unit::PxPct,
-    view::{ChangeFlags, View},
+    view::View,
 };
 use floem_reactive::create_effect;
 use floem_renderer::Renderer;
@@ -108,7 +108,7 @@ impl View for Label {
         format!("Label: {:?}", self.label).into()
     }
 
-    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn Any>) -> ChangeFlags {
+    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn Any>) {
         if let Ok(state) = state.downcast() {
             self.label = *state;
             self.text_layout = None;
@@ -116,9 +116,6 @@ impl View for Label {
             self.available_width = None;
             self.available_text_layout = None;
             cx.request_layout(self.id());
-            ChangeFlags::LAYOUT
-        } else {
-            ChangeFlags::empty()
         }
     }
 
diff --git a/src/views/list.rs b/src/views/list.rs
index b5611b86..51c8b15c 100644
--- a/src/views/list.rs
+++ b/src/views/list.rs
@@ -10,7 +10,7 @@ use smallvec::SmallVec;
 use crate::{
     context::{AppState, UpdateCx},
     id::Id,
-    view::{view_children_set_parent_id, ChangeFlags, View},
+    view::{view_children_set_parent_id, View},
 };
 
 pub(crate) type FxIndexSet<T> = indexmap::IndexSet<T, BuildHasherDefault<FxHasher>>;
@@ -118,11 +118,7 @@ impl<V: View + 'static, T> View for List<V, T> {
         "List".into()
     }
 
-    fn update(
-        &mut self,
-        cx: &mut UpdateCx,
-        state: Box<dyn std::any::Any>,
-    ) -> crate::view::ChangeFlags {
+    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn std::any::Any>) {
         if let Ok(diff) = state.downcast() {
             apply_diff(
                 self.id,
@@ -132,9 +128,6 @@ impl<V: View + 'static, T> View for List<V, T> {
                 &self.view_fn,
             );
             cx.request_all(self.id());
-            ChangeFlags::all()
-        } else {
-            ChangeFlags::empty()
         }
     }
 }
diff --git a/src/views/rich_text.rs b/src/views/rich_text.rs
index 29c62251..2f4f2dcb 100644
--- a/src/views/rich_text.rs
+++ b/src/views/rich_text.rs
@@ -10,7 +10,7 @@ use crate::{
     id::Id,
     style::{Style, TextOverflow},
     unit::PxPct,
-    view::{ChangeFlags, View},
+    view::View,
 };
 
 pub struct RichText {
@@ -54,7 +54,7 @@ impl View for RichText {
         .into()
     }
 
-    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn Any>) -> ChangeFlags {
+    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn Any>) {
         if let Ok(state) = state.downcast() {
             let mut text_layout: TextLayout = *state;
             if self.text_overflow == TextOverflow::Wrap && self.available_width > 0.0 {
@@ -63,9 +63,6 @@ impl View for RichText {
 
             self.text_layout = text_layout;
             cx.request_layout(self.id());
-            ChangeFlags::LAYOUT
-        } else {
-            ChangeFlags::empty()
         }
     }
 
diff --git a/src/views/scroll.rs b/src/views/scroll.rs
index 191af628..6592d0d0 100644
--- a/src/views/scroll.rs
+++ b/src/views/scroll.rs
@@ -12,7 +12,7 @@ use crate::{
     style::{Background, BorderColor, BorderRadius, PositionProp, Style, StyleSelector},
     style_class,
     unit::Px,
-    view::{ChangeFlags, View},
+    view::View,
 };
 
 enum ScrollState {
@@ -579,11 +579,7 @@ impl View for Scroll {
         "Scroll".into()
     }
 
-    fn update(
-        &mut self,
-        cx: &mut crate::context::UpdateCx,
-        state: Box<dyn std::any::Any>,
-    ) -> crate::view::ChangeFlags {
+    fn update(&mut self, cx: &mut crate::context::UpdateCx, state: Box<dyn std::any::Any>) {
         if let Ok(state) = state.downcast::<ScrollState>() {
             match *state {
                 ScrollState::EnsureVisible(rect) => {
@@ -606,9 +602,6 @@ impl View for Scroll {
                 }
             }
             cx.request_layout(self.id());
-            ChangeFlags::LAYOUT
-        } else {
-            ChangeFlags::empty()
         }
     }
 
diff --git a/src/views/stack.rs b/src/views/stack.rs
index fe780bc7..87ff40a3 100644
--- a/src/views/stack.rs
+++ b/src/views/stack.rs
@@ -1,12 +1,6 @@
 use taffy::style::FlexDirection;
 
-use crate::{
-    context::UpdateCx,
-    id::Id,
-    style::Style,
-    view::{ChangeFlags, View},
-    view_tuple::ViewTuple,
-};
+use crate::{context::UpdateCx, id::Id, style::Style, view::View, view_tuple::ViewTuple};
 
 pub struct Stack {
     id: Id,
@@ -88,13 +82,10 @@ impl View for Stack {
         }
     }
 
-    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn std::any::Any>) -> ChangeFlags {
+    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn std::any::Any>) {
         if let Ok(state) = state.downcast() {
             self.children = *state;
             cx.request_all(self.id);
-            ChangeFlags::all()
-        } else {
-            ChangeFlags::empty()
         }
     }
 }
diff --git a/src/views/svg.rs b/src/views/svg.rs
index c2b87bad..f556b450 100644
--- a/src/views/svg.rs
+++ b/src/views/svg.rs
@@ -8,11 +8,7 @@ use kurbo::Size;
 use peniko::Color;
 use sha2::{Digest, Sha256};
 
-use crate::{
-    id::Id,
-    view::{ChangeFlags, View},
-    views::Decorators,
-};
+use crate::{id::Id, view::View, views::Decorators};
 
 pub struct Svg {
     id: Id,
@@ -60,11 +56,7 @@ impl View for Svg {
         "Svg".into()
     }
 
-    fn update(
-        &mut self,
-        cx: &mut crate::context::UpdateCx,
-        state: Box<dyn std::any::Any>,
-    ) -> crate::view::ChangeFlags {
+    fn update(&mut self, cx: &mut crate::context::UpdateCx, state: Box<dyn std::any::Any>) {
         if let Ok(state) = state.downcast::<String>() {
             let text = &*state;
             self.svg_tree = Tree::from_str(text, &usvg::Options::default()).ok();
@@ -75,9 +67,6 @@ impl View for Svg {
             self.svg_hash = Some(hash);
 
             cx.request_layout(self.id());
-            ChangeFlags::LAYOUT
-        } else {
-            ChangeFlags::empty()
         }
     }
 
diff --git a/src/views/tab.rs b/src/views/tab.rs
index 2ff86ef3..1c2a368b 100644
--- a/src/views/tab.rs
+++ b/src/views/tab.rs
@@ -4,12 +4,7 @@ use floem_reactive::{as_child_of_current_scope, create_effect, Scope};
 use smallvec::SmallVec;
 use taffy::style::Display;
 
-use crate::{
-    context::UpdateCx,
-    id::Id,
-    style::DisplayProp,
-    view::{ChangeFlags, View},
-};
+use crate::{context::UpdateCx, id::Id, style::DisplayProp, view::View};
 
 use super::{apply_diff, diff, Diff, DiffOpAdd, FxIndexSet, HashRun};
 
@@ -132,11 +127,7 @@ impl<V: View + 'static, T> View for Tab<V, T> {
         format!("Tab: {}", self.active).into()
     }
 
-    fn update(
-        &mut self,
-        cx: &mut UpdateCx,
-        state: Box<dyn std::any::Any>,
-    ) -> crate::view::ChangeFlags {
+    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn std::any::Any>) {
         if let Ok(state) = state.downcast::<TabState<T>>() {
             match *state {
                 TabState::Diff(diff) => {
@@ -156,9 +147,6 @@ impl<V: View + 'static, T> View for Tab<V, T> {
             for (child, _) in self.children.iter().flatten() {
                 cx.request_all(child.id());
             }
-            ChangeFlags::all()
-        } else {
-            ChangeFlags::empty()
         }
     }
 
diff --git a/src/views/text_input.rs b/src/views/text_input.rs
index 4467e929..5d51ab42 100644
--- a/src/views/text_input.rs
+++ b/src/views/text_input.rs
@@ -26,7 +26,6 @@ use crate::{
     context::{EventCx, UpdateCx},
     event::Event,
     id::Id,
-    view::ChangeFlags,
 };
 
 use super::Decorators;
@@ -716,13 +715,11 @@ impl View for TextInput {
         format!("TextInput: {:?}", self.buffer.get_untracked()).into()
     }
 
-    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn Any>) -> ChangeFlags {
+    fn update(&mut self, cx: &mut UpdateCx, state: Box<dyn Any>) {
         if state.downcast::<String>().is_ok() {
             cx.request_layout(self.id());
-            ChangeFlags::LAYOUT
         } else {
             dbg!("downcast failed");
-            ChangeFlags::empty()
         }
     }
 
diff --git a/src/views/virtual_list.rs b/src/views/virtual_list.rs
index 510bb77b..744b53ef 100644
--- a/src/views/virtual_list.rs
+++ b/src/views/virtual_list.rs
@@ -8,7 +8,7 @@ use taffy::{prelude::Node, style::Dimension};
 use crate::{
     context::LayoutCx,
     id::Id,
-    view::{self, ChangeFlags, View},
+    view::{self, View},
 };
 
 use super::{apply_diff, diff, Diff, DiffOpAdd, FxIndexSet, HashRun};
@@ -237,17 +237,13 @@ impl<V: View + 'static, T> View for VirtualList<V, T> {
         "VirtualList".into()
     }
 
-    fn update(
-        &mut self,
-        cx: &mut crate::context::UpdateCx,
-        state: Box<dyn std::any::Any>,
-    ) -> crate::view::ChangeFlags {
+    fn update(&mut self, cx: &mut crate::context::UpdateCx, state: Box<dyn std::any::Any>) {
         if let Ok(state) = state.downcast::<VirtualListState<T>>() {
             if self.before_size == state.before_size
                 && self.after_size == state.after_size
                 && state.diff.is_empty()
             {
-                return ChangeFlags::empty();
+                return;
             }
             self.before_size = state.before_size;
             self.after_size = state.after_size;
@@ -259,9 +255,6 @@ impl<V: View + 'static, T> View for VirtualList<V, T> {
                 &self.view_fn,
             );
             cx.request_all(self.id());
-            ChangeFlags::all()
-        } else {
-            ChangeFlags::empty()
         }
     }
 
diff --git a/src/window_handle.rs b/src/window_handle.rs
index c320b421..93a85958 100644
--- a/src/window_handle.rs
+++ b/src/window_handle.rs
@@ -20,11 +20,10 @@ use crate::unit::UnitExt;
 #[cfg(target_os = "linux")]
 use crate::views::{container_box, stack, Decorators};
 use crate::{
-    action::exec_after,
     animate::{AnimPropKind, AnimUpdateMsg, AnimValue, AnimatedProp, SizeUnit},
     context::{
-        AppState, EventCx, LayoutCx, MoveListener, PaintCx, PaintState, ResizeListener, StyleCx,
-        UpdateCx,
+        AppState, ChangeFlags, EventCx, FrameUpdate, LayoutCx, MoveListener, PaintCx, PaintState,
+        ResizeListener, StyleCx, UpdateCx,
     },
     event::{Event, EventListener},
     id::{Id, IdPath, ID_PATHS},
@@ -38,7 +37,7 @@ use crate::{
         CENTRAL_UPDATE_MESSAGES, CURRENT_RUNNING_VIEW_HANDLE, DEFERRED_UPDATE_MESSAGES,
         UPDATE_MESSAGES,
     },
-    view::{view_children_set_parent_id, ChangeFlags, View},
+    view::{view_children_set_parent_id, View},
 };
 
 /// The top-level window handle that owns the winit Window.
@@ -312,7 +311,7 @@ impl WindowHandle {
         self.scale = scale;
         let scale = self.scale * self.app_state.scale;
         self.paint_state.set_scale(scale);
-        self.request_paint();
+        self.schedule_repaint();
     }
 
     pub(crate) fn theme_changed(&mut self, theme: Theme) {
@@ -338,7 +337,7 @@ impl WindowHandle {
         self.style();
         self.layout();
         self.process_update();
-        self.request_paint();
+        self.schedule_repaint();
     }
 
     pub(crate) fn position(&mut self, point: Point) {
@@ -475,16 +474,26 @@ impl WindowHandle {
         cx.clear();
         cx.compute_view_layout(&mut self.view);
 
-        if self.app_state.capture.is_none() && !self.app_state.animated.is_empty() {
-            let animated = self.app_state.animated.clone();
-            exec_after(Duration::from_millis(1), move |_| {
-                for id in animated {
-                    id.request_change(ChangeFlags::STYLE);
-                }
-            });
+        taffy_duration
+    }
+
+    pub fn render_frame(&mut self) {
+        // Processes updates scheduled on this frame.
+        for update in mem::take(&mut self.app_state.scheduled_updates) {
+            match update {
+                FrameUpdate::Style(id) => self.app_state.request_style(id),
+                FrameUpdate::Layout(id) => self.app_state.request_layout(id),
+                FrameUpdate::Paint(id) => self.app_state.request_paint(id),
+            }
         }
 
-        taffy_duration
+        self.process_update_no_paint();
+        self.paint();
+
+        // Request a new frame if there's any scheduled updates.
+        if !self.app_state.scheduled_updates.is_empty() {
+            self.schedule_repaint();
+        }
     }
 
     pub fn paint(&mut self) -> Option<DynamicImage> {
@@ -493,28 +502,10 @@ impl WindowHandle {
             paint_state: &mut self.paint_state,
             transform: Affine::IDENTITY,
             clip: None,
-            color: None,
-            font_size: None,
-            font_family: None,
-            font_weight: None,
-            font_style: None,
-            line_height: None,
             z_index: None,
             saved_transforms: Vec::new(),
             saved_clips: Vec::new(),
-            saved_colors: Vec::new(),
-            saved_font_sizes: Vec::new(),
-            saved_font_families: Vec::new(),
-            saved_font_weights: Vec::new(),
-            saved_font_styles: Vec::new(),
-            saved_line_heights: Vec::new(),
             saved_z_indexes: Vec::new(),
-            scroll_bar_rounded: None,
-            scroll_bar_thickness: None,
-            scroll_bar_edge_width: None,
-            saved_scroll_bar_roundeds: Vec::new(),
-            saved_scroll_bar_thicknesses: Vec::new(),
-            saved_scroll_bar_edge_widths: Vec::new(),
         };
         cx.paint_state
             .renderer
@@ -539,13 +530,7 @@ impl WindowHandle {
                 window.pre_present_notify();
             }
         }
-        let image = cx.paint_state.renderer.finish();
-
-        if cx.app_state.capture.is_none() {
-            self.process_update();
-        }
-
-        image
+        cx.paint_state.renderer.finish()
     }
 
     pub(crate) fn capture(&mut self) -> Capture {
@@ -563,8 +548,7 @@ impl WindowHandle {
         // Ensure we run layout and styling again for accurate timing. We also need to ensure
         // styles are recomputed to capture them.
         self.app_state.view_states.values_mut().for_each(|state| {
-            state.request_layout = true;
-            state.request_style = true;
+            state.requested_changes = ChangeFlags::all();
         });
 
         fn get_taffy_depth(taffy: &taffy::Taffy, root: taffy::node::Node) -> usize {
@@ -612,9 +596,17 @@ impl WindowHandle {
     }
 
     pub(crate) fn process_update(&mut self) {
-        let mut flags = ChangeFlags::empty();
+        if self.process_update_no_paint() {
+            self.schedule_repaint();
+        }
+    }
+
+    /// Processes updates and runs style and layout if needed.
+    /// Returns `true` if painting is required.
+    pub(crate) fn process_update_no_paint(&mut self) -> bool {
+        let mut paint = false;
         loop {
-            flags |= self.process_update_messages();
+            self.process_update_messages();
             if !self.needs_layout()
                 && !self.needs_style()
                 && !self.has_deferred_update_messages()
@@ -624,33 +616,23 @@ impl WindowHandle {
             }
 
             if self.needs_style() {
-                flags |= ChangeFlags::STYLE;
+                paint = true;
                 self.style();
             }
 
             if self.needs_layout() {
-                flags |= ChangeFlags::LAYOUT;
+                paint = true;
                 self.layout();
             }
 
-            flags |= self.process_deferred_update_messages();
-            flags |= self.process_anim_update_messages();
+            self.process_deferred_update_messages();
+            self.process_anim_update_messages();
         }
 
         self.set_cursor();
 
-        if !flags.is_empty() {
-            self.request_paint();
-        }
-
-        if !self.app_state.transitioning.is_empty() {
-            let transitioning = mem::take(&mut self.app_state.transitioning);
-            exec_after(Duration::from_millis(1), move |_| {
-                for id in transitioning {
-                    id.request_change(ChangeFlags::STYLE);
-                }
-            });
-        }
+        // TODO: This should only use `self.app_state.request_paint)`
+        paint || mem::take(&mut self.app_state.request_paint)
     }
 
     fn process_central_messages(&self) {
@@ -685,8 +667,7 @@ impl WindowHandle {
         });
     }
 
-    fn process_update_messages(&mut self) -> ChangeFlags {
-        let mut flags = ChangeFlags::empty();
+    fn process_update_messages(&mut self) {
         loop {
             self.process_central_messages();
             let msgs =
@@ -700,22 +681,15 @@ impl WindowHandle {
                 };
                 match msg {
                     UpdateMessage::RequestChange { id, flags: changes } => {
-                        flags |= changes;
                         if changes.contains(ChangeFlags::STYLE) {
                             cx.app_state.request_style(id);
                         }
                         if changes.contains(ChangeFlags::LAYOUT) {
                             cx.app_state.request_layout(id);
                         }
-                        if changes.contains(ChangeFlags::PAINT) {
-                            cx.app_state.request_paint(id);
-                        }
                     }
                     UpdateMessage::RequestPaint => {
-                        flags |= ChangeFlags::PAINT;
-                    }
-                    UpdateMessage::RequestLayout { id } => {
-                        cx.app_state.request_layout(id);
+                        cx.app_state.request_paint = true;
                     }
                     UpdateMessage::Focus(id) => {
                         if cx.app_state.focus != Some(id) {
@@ -754,7 +728,7 @@ impl WindowHandle {
                     UpdateMessage::State { id, state } => {
                         let id_path = ID_PATHS.with(|paths| paths.borrow().get(&id).cloned());
                         if let Some(id_path) = id_path {
-                            flags |= cx.update_view(&mut self.view, id_path.dispatch(), state);
+                            cx.update_view(&mut self.view, id_path.dispatch(), state);
                         }
                     }
                     UpdateMessage::BaseStyle { id, style } => {
@@ -866,9 +840,9 @@ impl WindowHandle {
                         state.cleanup_listener = Some(action);
                     }
                     UpdateMessage::Animation { id, animation } => {
-                        cx.app_state.animated.insert(id);
                         let view_state = cx.app_state.view_state(id);
                         view_state.animation = Some(animation);
+                        cx.request_style(id);
                     }
                     UpdateMessage::WindowScale(scale) => {
                         cx.app_state.scale = scale;
@@ -931,33 +905,24 @@ impl WindowHandle {
                 }
             }
         }
-        flags
     }
 
-    fn process_deferred_update_messages(&mut self) -> ChangeFlags {
+    fn process_deferred_update_messages(&mut self) {
         self.process_central_messages();
-        let mut flags = ChangeFlags::empty();
         let msgs = DEFERRED_UPDATE_MESSAGES
             .with(|msgs| msgs.borrow_mut().remove(&self.id).unwrap_or_default());
-        if msgs.is_empty() {
-            return flags;
-        }
-
         let mut cx = UpdateCx {
             app_state: &mut self.app_state,
         };
         for (id, state) in msgs {
             let id_path = ID_PATHS.with(|paths| paths.borrow().get(&id).cloned());
             if let Some(id_path) = id_path {
-                flags |= cx.update_view(&mut self.view, id_path.dispatch(), state);
+                cx.update_view(&mut self.view, id_path.dispatch(), state);
             }
         }
-
-        flags
     }
 
-    fn process_anim_update_messages(&mut self) -> ChangeFlags {
-        let mut flags = ChangeFlags::empty();
+    fn process_anim_update_messages(&mut self) {
         let msgs: Vec<AnimUpdateMsg> = ANIM_UPDATE_MESSAGES.with(|msgs| {
             let mut msgs = msgs.borrow_mut();
             let len = msgs.len();
@@ -972,20 +937,13 @@ impl WindowHandle {
                     val,
                 } => {
                     let view_id = self.app_state.get_view_id_by_anim_id(anim_id);
-                    flags |= self.process_update_anim_prop(view_id, kind, val);
+                    self.process_update_anim_prop(view_id, kind, val);
                 }
             }
         }
-
-        flags
     }
 
-    fn process_update_anim_prop(
-        &mut self,
-        view_id: Id,
-        kind: AnimPropKind,
-        val: AnimValue,
-    ) -> ChangeFlags {
+    fn process_update_anim_prop(&mut self, view_id: Id, kind: AnimPropKind, val: AnimValue) {
         let layout = self.app_state.get_layout(view_id).unwrap();
         let view_state = self.app_state.view_state(view_id);
         let anim = view_state.animation.as_mut().unwrap();
@@ -1029,15 +987,21 @@ impl WindowHandle {
         anim.props_mut().insert(kind, prop);
         anim.begin();
 
-        ChangeFlags::LAYOUT
+        self.app_state.request_style(view_id);
     }
 
     fn needs_layout(&mut self) -> bool {
-        self.app_state.view_state(self.view.id()).request_layout
+        self.app_state
+            .view_state(self.view.id())
+            .requested_changes
+            .contains(ChangeFlags::LAYOUT)
     }
 
     fn needs_style(&mut self) -> bool {
-        self.app_state.view_state(self.view.id()).request_style
+        self.app_state
+            .view_state(self.view.id())
+            .requested_changes
+            .contains(ChangeFlags::STYLE)
     }
 
     fn has_deferred_update_messages(&self) -> bool {
@@ -1099,7 +1063,7 @@ impl WindowHandle {
         }
     }
 
-    fn request_paint(&self) {
+    fn schedule_repaint(&self) {
         if let Some(window) = self.window.as_ref() {
             window.request_redraw();
         }