some perf gains

Author: raphamorim

frontends/rioterm/src/application.rs

@@ -244,6 +244,9 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                         if self.config.renderer.disable_unfocused_render
                             && !route.window.is_focused
                         {
+                            if route.window.screen.renderer.scrollbar.needs_redraw() {
+                                route.request_redraw();
+                            }
                             return;
                         }
 
@@ -430,6 +433,8 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                     } else {
                         route.clear_errors();
                     }
+
+                    route.request_redraw();
                 }
             }
             RioEventType::Rio(RioEvent::Exit | RioEvent::Quit) => {
@@ -585,7 +590,7 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                 }
             }
             RioEventType::Rio(RioEvent::PrepareRenderOnRoute(millis, route_id)) => {
-                let timer_id = TimerId::new(Topic::RenderRoute, route_id);
+                let timer_id = TimerId::new(Topic::ScheduledRenderRoute, route_id);
                 let event = EventPayload::new(
                     RioEventType::Rio(RioEvent::RenderRoute(route_id)),
                     window_id,
@@ -1352,7 +1357,7 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                         .assistant
                         .hover(mx, my, win_w, scale)
                     {
-                        route.request_redraw();
+                        route.request_overlay_redraw();
                     }
 
                     if route
@@ -1383,7 +1388,7 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                         .command_palette
                         .hover(mx, my, win_w, scale)
                     {
-                        route.request_redraw();
+                        route.request_overlay_redraw();
                     }
                     route.window.winit_window.set_cursor(CursorIcon::Default);
                     return;
@@ -1824,6 +1829,7 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                     false,
                 );
                 route.window.configure_window(&self.config);
+                route.request_redraw();
             }
 
             WindowEvent::DroppedFile(path) => {
@@ -1841,6 +1847,7 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                 }
 
                 route.window.screen.resize(new_size);
+                route.request_redraw();
             }
 
             WindowEvent::ScaleFactorChanged {
@@ -1853,6 +1860,7 @@ impl ApplicationHandler<EventPayload> for Application<'_> {
                     .screen
                     .set_scale(scale, route.window.winit_window.inner_size());
                 route.window.update_vblank_interval();
+                route.request_redraw();
             }
 
             WindowEvent::RedrawRequested => {

frontends/rioterm/src/context/mod.rs

@@ -539,6 +539,14 @@ impl<T: EventListener + Clone + std::marker::Send + 'static> ContextManager<T> {
         );
     }
 
+    #[inline]
+    pub fn schedule_render_on_route(&mut self, millis: u64) {
+        self.event_proxy.send_event(
+            RioEvent::PrepareRenderOnRoute(millis, self.current_route),
+            self.window_id,
+        );
+    }
+
     #[inline]
     pub fn report_error_fonts_not_found(&mut self, fonts_not_found: Vec<SugarloafFont>) {
         if !fonts_not_found.is_empty() {

frontends/rioterm/src/grid_emit.rs

@@ -705,28 +705,20 @@ fn ensure_drawable_sprite(
     )
 }
 
-/// Emit a cursor sprite into the appropriate `fg_rows` slot. Caller
-/// is responsible for clearing the OTHER slot (so a previous-frame
-/// block doesn't linger when this frame draws a hollow, etc.) — see
-/// `grid.clear_cursor()`. `addCursor`
-///.
-pub fn emit_cursor_sprite(
+pub fn cursor_sprite_cell(
     grid: &mut GridRenderer,
     style: CursorRenderStyle,
     col: u16,
     row: u16,
     color: [u8; 4],
     cell_w: u32,
     cell_h: u32,
-) {
+) -> Option<(bool, CellText)> {
     let sprite = style.sprite();
     let thickness = cursor_thickness(cell_h);
-    let Some(slot) = ensure_cursor_sprite_slot(grid, sprite, cell_w, cell_h, thickness)
-    else {
-        return;
-    };
+    let slot = ensure_cursor_sprite_slot(grid, sprite, cell_w, cell_h, thickness)?;
     if slot.w == 0 || slot.h == 0 {
-        return;
+        return None;
     }
     let cursor_cell = CellText {
         glyph_pos: [slot.x as u32, slot.y as u32],
@@ -742,11 +734,7 @@ pub fn emit_cursor_sprite(
         page: slot.page,
         _pad: 0,
     };
-    if sprite.is_block_slot() {
-        grid.set_block_cursor(&[cursor_cell]);
-    } else {
-        grid.set_non_block_cursor(&[cursor_cell]);
-    }
+    Some((sprite.is_block_slot(), cursor_cell))
 }
 
 /// Underline thickness in physical pixels. fallback

frontends/rioterm/src/renderer/scrollbar.rs

@@ -427,19 +427,43 @@ impl Scrollbar {
             .map(|(_, t)| *t)
     }
 
-    /// Returns true if any scrollbar is still animating (visible or fading).
+    /// Returns true if a scrollbar needs per-frame redraws right now:
+    /// while dragging or while a fade-out is in progress. Returns false
+    /// during the fully-visible delay before the fade starts — callers
+    /// must pair this with `next_wake_in()` to schedule the redraw that
+    /// kicks off the fade.
     pub fn needs_redraw(&mut self) -> bool {
         if !self.enabled {
             return false;
         }
         if self.drag_state.is_some() {
             return true;
         }
-        // Prune fully faded entries and check if any are still active
         let deadline = FADE_OUT_DELAY_MS + FADE_OUT_DURATION_MS;
         self.last_scroll_times
             .retain(|(_, t)| t.elapsed().as_millis() < deadline);
-        !self.last_scroll_times.is_empty()
+        self.last_scroll_times
+            .iter()
+            .any(|(_, t)| t.elapsed().as_millis() >= FADE_OUT_DELAY_MS)
+    }
+
+    pub fn next_wake_in(&self) -> Option<std::time::Duration> {
+        if !self.enabled || self.drag_state.is_some() {
+            return None;
+        }
+        self.last_scroll_times
+            .iter()
+            .filter_map(|(_, t)| {
+                let elapsed = t.elapsed().as_millis();
+                if elapsed < FADE_OUT_DELAY_MS {
+                    Some(std::time::Duration::from_millis(
+                        (FADE_OUT_DELAY_MS - elapsed) as u64,
+                    ))
+                } else {
+                    None
+                }
+            })
+            .min()
     }
 }
 

frontends/rioterm/src/scheduler.rs

@@ -25,6 +25,7 @@ impl TimerId {
 pub enum Topic {
     Render,
     RenderRoute,
+    ScheduledRenderRoute,
     UpdateConfig,
     CursorBlinking,
     UpdateTitles,

frontends/rioterm/src/screen/mod.rs

@@ -4138,15 +4138,17 @@ impl Screen<'_> {
                 // `cursor.style()`):
                 // 1. Decide render style with strict priority:
                 // preedit > visible > focused > blink > shape.
-                // 2. Always clear both cursor slots first — last
-                // frame's sprite (if any) needs to disappear
-                // whether we emit a new one or not.
-                // 3. Some(style): emit a sprite into slot 0 (block)
-                // or slot rows+1 (others). For Block we ALSO
-                // write the bg-tint uniforms below so the bg
-                // fragment paints the block + the text shader
-                // inverts the underlying glyph.
-                // 4. None: leave both slots empty + zero uniforms.
+                // 2. Some(style): build the sprite for the block
+                // slot (drawn under text; the bg-tint uniforms
+                // below make the bg fragment paint the block +
+                // the text shader invert the underlying glyph)
+                // or the tail slot (bar/underline, drawn over
+                // text). None: both stay empty + zero uniforms.
+                // 3. One `grid.set_cursor(block, tail)` call
+                // replaces both slots. It diffs against last
+                // frame and only dirties cursor buffers on
+                // change — do NOT clear the slots beforehand,
+                // that would dirty them every frame.
                 let render_style = crate::grid_emit::cursor_render_style(
                     crate::grid_emit::CursorRenderInputs {
                         visible: p.cursor_visible,
@@ -4157,7 +4159,10 @@ impl Screen<'_> {
                         shape: p.cursor_shape,
                     },
                 );
-                grid.clear_cursor();
+                let mut block_cursor: Option<rio_backend::sugarloaf::grid::CellText> =
+                    None;
+                let mut tail_cursor: Option<rio_backend::sugarloaf::grid::CellText> =
+                    None;
                 if let Some(style) = render_style {
                     let cell_w = p.cell_w.round().clamp(1.0, u32::MAX as f32) as u32;
                     let cell_h = p.cell_h.round().clamp(1.0, u32::MAX as f32) as u32;
@@ -4167,16 +4172,23 @@ impl Screen<'_> {
                         (p.cursor_color[2].clamp(0.0, 1.0) * 255.0) as u8,
                         255,
                     ];
-                    crate::grid_emit::emit_cursor_sprite(
+                    if let Some((is_block, cell)) = crate::grid_emit::cursor_sprite_cell(
                         grid,
                         style,
                         p.cursor_col,
                         p.cursor_row,
                         cursor_color,
                         cell_w,
                         cell_h,
-                    );
+                    ) {
+                        if is_block {
+                            block_cursor = Some(cell);
+                        } else {
+                            tail_cursor = Some(cell);
+                        }
+                    }
                 }
+                grid.set_cursor(block_cursor.as_slice(), tail_cursor.as_slice());
 
                 // Panel's grid origin in drawable-pixel space =
                 // window scaled_margin + the panel's layout rect
@@ -4299,6 +4311,11 @@ impl Screen<'_> {
                 .set_dirty();
         }
 
+        if let Some(wake_in) = self.renderer.scrollbar.next_wake_in() {
+            self.context_manager
+                .schedule_render_on_route(wake_in.as_millis() as u64);
+        }
+
         // In case the configuration of blinking cursor is enabled
         // TODO: enable blinking for selection after adding debounce (https://github.com/raphamorim/rio/issues/437)
         if self.renderer.is_window_focused

rio-window/src/platform_impl/macos/display_link.rs

@@ -198,6 +198,11 @@ impl DisplayLink {
         }
     }
 
+    #[inline]
+    pub fn is_running(&self) -> bool {
+        self.is_running.get()
+    }
+
     /// Start VSync-synchronized rendering
     pub fn start(&self) -> Result<(), &'static str> {
         if self.is_running.get() {
@@ -214,9 +219,8 @@ impl DisplayLink {
                 _ds: self.dispatch_source,
             });
 
-            // Start CVDisplayLink
             let result = CVDisplayLinkStart(self.display_link);
-            if result != 0 {
+            if result != 0 && result != -6671 {
                 dispatch_suspend(super::dispatcher::dispatch_sys::dispatch_object_t {
                     _ds: self.dispatch_source,
                 });
@@ -251,10 +255,11 @@ impl DisplayLink {
                 _ds: self.dispatch_source,
             });
 
+            self.is_running.set(false);
+
             if result != 0 {
                 Err("Failed to stop CVDisplayLink")
             } else {
-                self.is_running.set(false);
                 tracing::info!(
                     "CVDisplayLink stopped for window {:?}",
                     self.user_data.window_id