Windows Multi-window Focus Based Rendering

[clneale]

Hey team,

I've been using Slint for a while now and have developed a low-latency RTSP streaming application with it and GStreamer for remote operating machinery that is very nice to use.

I am trying to add two remote windows for additional streams. When I try to run the app on Windows 11 (works fine on mac) it only wants to render the window content of the in-focus window.

I've reduced this to a very basic example using slint, and winit to force redraw requests, but the problem still persists.
The window title will update, but the contents will not update when out-of-focus.
Am I doing something wrong, or is this is an actual slint issue?

Code below:

use slint::{winit_030::WinitWindowAccessor, ComponentHandle, PlatformError, Timer, Weak};
use std::time::Duration;
slint::include_modules!();

fn main() -> Result<(), slint::PlatformError> {
    slint::BackendSelector::new()
        .backend_name("winit".into())
        .select()?;
    let window_1 = AppWindow::new()?;

    let window_2 = AppWindow::new()?;

    window_1
        .window()
        .set_rendering_notifier(|e, g| println!("rendering window 1: {:?}", e))
        .unwrap();

    window_2
        .window()
        .set_rendering_notifier(|e, g| println!("rendering window 2: {:?}", e))
        .unwrap();

    window_1.on_show_settings(|| {
        let dialog = SettingsDialog::new().unwrap();
        dialog.show().unwrap();
    });
    window_1.show()?;
    window_2.show()?;
    let windows = vec![window_1.as_weak(), window_2.as_weak()];
    let timer = Timer::default();
    let mut counter1 = 0;
    timer.start(
        slint::TimerMode::Repeated,
        Duration::from_millis(16),
        move || {
            force_redraw_all_windows(&windows, &mut counter1).unwrap();
        },
    );

    slint::run_event_loop()?;
    Ok(())
}

fn force_redraw_all_windows(
    windows: &[Weak<AppWindow>],
    counter: &mut i32,
) -> Result<(), PlatformError> {
    for weak_window in windows {
        if let Some(window) = weak_window.upgrade() {
            window
                .window()
                .with_winit_window(|winit_window: &winit::window::Window| {
                    winit_window.request_redraw();
                    *counter += 1;
                    winit_window.set_title(&format!("{}", counter));
                    eprintln!("window id = {:#?}", winit_window.id());
                    eprintln!("Counter value: {}", counter);
                });
        }
    }
    Ok(())
}

import { Button, StandardButton, ProgressIndicator, VerticalBox } from "std-widgets.slint";

export component SettingsDialog inherits Dialog {

    title: "Settings";

    VerticalBox {
        spacing: 5px;
        ProgressIndicator {
            indeterminate: true;
        }

        Text {
            text: "Multi-window trial";
        }
    }

    StandardButton {
        kind: ok;
    }

    StandardButton {
        kind: cancel;
    }
}

export component AppWindow inherits Window {
    height: 200px;
    width: 200px;

    callback show-settings();
    property <int> value: 100;
    timer := Timer {
        interval: 1s;
        running: true;
        triggered() => {
            value -= 1;
            if (value == 0) {
                self.running = false;
            }
        }
    }

    VerticalBox {
        spacing: 10px;
        Text {
            text: value;
        }

        ProgressIndicator {
            indeterminate: true;
        }

        Button {
            text: "Show settings";
            clicked => {
                root.show-settings()
            }
        }
    }
}

For completeness I have tried this:

• with and without winit forcing redraw requests.
• with every winit backend renderer options
• v1.8 and v.12 of slint

I thought this was an winit issue to begin with, but the RenderRequested events seem to come through no matter the focus using the winit only code below:

use winit::event::{Event, WindowEvent};
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::WindowBuilder;

fn main() {
    let event_loop = EventLoop::new();
    let window1 = WindowBuilder::new()
        .with_title("Window 1")
        .build(&event_loop)
        .unwrap();
    let window2 = WindowBuilder::new()
        .with_title("Window 2")
        .build(&event_loop)
        .unwrap();

    let mut counter1 = 0;
    let mut counter2 = 0;

    event_loop.run(move |event, _, control_flow| {
        *control_flow = ControlFlow::Poll;
        match event {
            Event::WindowEvent {
                event: WindowEvent::CloseRequested,
                ..
            } => {
                *control_flow = ControlFlow::Exit;
            }
            Event::MainEventsCleared => {
                counter1 += 1;
                counter2 += 1;
                window1.set_title(&format!("Window 1: {}", counter1));
                window2.set_title(&format!("Window 2: {}", counter2));
                window1.request_redraw();
                window2.request_redraw();
            }
            Event::RedrawRequested(id) => {
                // Add basic rendering logic here if needed
                println!("Redraw requested for window_{:?}", id);
            }
            _ => {}
        }
    });
}

Any help would be hugely appreciated as I have burnt way too many days trying work around this myself.

Cheers, Chris.

[tronical]

Hi Chris. I tried your example and I can reproduce the issue on Windows. It's... rather strange indeed. I can confirm that we do invoke the renderer on the other windows. Even with the software renderer (and soft buffer), the window decorations update with the new title but the contents don't.

[clneale]

Hey Simon. Thanks for the speedy reply. My understanding is that the WIN32 api does try to optimise rendering by prioritising the in-focus windows, which I thought might be playing a part in this. The winit only trial seems to debunk that though.
I don't run QT (anymore) so I haven't got an install handy to try and isolate the issue to winit.
One really odd discovery, is that sometimes if you have the individual windows positioned over screen edges, in a multi-display setup, they will all render. The performance of the out-of-focus windows is noticeably worse though.

[tronical]

I played around a bit more and I think this is in essence due to the lack of frame throttling. I hacked together a quick refresh timer to throttle the (otherwise on windows unthrottled) winit::Window::request_redraw() and that fixed it nicely. I've filed #8826 .

[tronical]

I think #8828 should fix this. Could you give it a try?

With this PR, your example works, with one single change: It's important to avoid calling request_redraw() directly on the winit::window::Window and instead, in force_redraw_all_windows replace the call to winit_window.request_redraw() with window.window().request_redraw(). Otherwise Slint's built-in throttle won't help.

[clneale]

I gave your PR a spin this morning, and while it is closer to the goal, the issue is still present.
Am I write in assuming that given your code changes in the PR, and the fact you are already calling request_redraw on all windows (out-of-focus included), that having my own timer requesting redraws on all windows is now redundant?
I've attempted with and without the calls to force_redraw_all_windows() and the results are the same.
There is correlation (not when screen recording apparently) to the cursor moving event and a redraw. If I keep the mouse moving around the desktop everything updates as expected. Once I stop, the out-of-focus windows freeze/occasionally update.

I added a 3rd window to the mix to show off the differences in rendering, depending on which window is selected.

Screen.Recording.2025-07-02.051558.mp4

Screen.Recording.2025-07-02.051755.mp4

Screen.Recording.2025-07-02.053139.mp4

[clneale]

I compared your sample repo with the code I tested yesterday, and noticed you had renderer-skia feature flag set.
Can confirm that all works well, but only with skia.
Femtovg and software still exhibit the same issue for me.

Once I update the Slint version and feature flags in my production application, I will give some more feedback.
What I would give to be able to run on linux or mac in production!

[clneale]

Hi Simon,
Sorry for the delay in getting back to you.
Out of curiosity does your implementation work both with, and without renderer-skia?
I am debugging on a production system today and will pass on anything of interest.

Cheers, Chris.

[tronical]

No worries. Yes, for me it works with Skia and with the software renderer.

However, I noticed one important detail in the example repo I posted: By the time I pushed the repo, I had Cargo.toml edited to point to the old version of Slint that reproduced the bug - so the repo would default to not working and required an edit. I pushed a fix to the repo, so if you pull, it should work out of the box.

[clneale]

Thanks Simon. I did pick up on the mistake in the original repo after reading through your fix in the PR ;)
I can confirm that the site trial went well and the issue is no longer present!

[clneale]

Hey Simon,
Do you use a particular tool or library to analyse problems like this through Slint?

In the Windows world, I keep running into to odd issues with different renderers/use cases and I would like to be able to assist in improving the usability/reliability/speed of Slint on Windows without just dumping mounds of my own source code on you to sift through.

Nearly all of my projects revolve around Slint - GStreamer - Tokio for low-latency high-fps video streaming from cameras over networks to control room displays for remote machine operations so spending the time to work through these issues is worth it.

And yes, unfortunately I am stuck with using Windows for the foreseeable future! :'(