Build a cross-platform native webview-based window with Rust using the same library that built the Tauri framework.

[AriBermeki]

If you had the opportunity to have someone create a native window based on webviews using a system language (Rust), what would you want? What pywebview does not offer

[rodja]

A major pain-point for NiceGUI's pywebview integration is that it is not async. It would be great to have a native window library with asyncio support so we could directly integrate it instead of using the current (incomplete) wrapping.

[AriBermeki]

@rodja

That was a problem for me too. That's why I started this discussion.

[AriBermeki]

Will it be a problem for NiceGUI if the communication between Webview and Python is done via TCP and IPC (stdin/stdout)?

[AriBermeki]

Communication example between rust and python

bbbb.mp4

[rodja]

As long as there is a proper Python API wrapping the tcp/icp details I do not see a problem with that approach.

[AriBermeki]

@rodja

I need help with python regarding abstract asyncio event loop and event loop policy and same outbox data send system as nicegui but with TCP and IPC and not socketio

[AriBermeki]

Imagine a library that works on the same principle as NiceGUI. A JSON configuration object is passed to Rust, after which Rust recursively creates the corresponding structures. When an event is sent from the frontend to Rust, the system checks whether this event needs to be processed on the Python side or stays in Rust. If Python is responsible, the corresponding event data is passed to Python. In this way, the system enables seamless integration with a low-level system language such as Rust.

[rodja]

When an event is sent from the frontend to Rust, the system checks whether this event needs to be processed on the Python side or stays in Rust.

Why does the frontend need to communicate with Rust? I would assume that the control over the native windows is fully in the hands of Python (and hence the NiceGUI developer).

[AriBermeki]

I think we're talking past each other. This library is intended to replace pywebview. It is not specifically built for nicegui. Anyone can integrate their application with or without nicegui into it. That's why Pyframe has its own javascript_python_event_api. For example, nicegui uses these methods from pywebview.

NiceGUI WindowProxy

• get_always_on_top()
• set_always_on_top(on_top: bool)
• get_size()
• get_position()
• load_url(url: str)
• load_html(content: str, base_uri: str = ...)
• load_css(stylesheet: str)
• set_title(title: str)
• get_cookies()
• get_current_url()
• destroy()
• show()
• hide()
• set_window_size(width: int, height: int)
• resize(width: int, height: int, fix_point: FixPoint = FixPoint.NORTH | FixPoint.WEST)
• maximize()
• minimize()
• restore()
• toggle_fullscreen()
• move(x: int, y: int)
• evaluate_js(script: str)
• create_confirmation_dialog(title: str, message: str)
• create_file_dialog(dialog_type: int, directory: str, allow_multiple: bool, save_filename: str, file_types: Tuple[str, ...])
• signal_server_shutdown()

I strongly assume that you are not using PyWebView's JavaScript API since you have built your own API using FastAPI and SocketIO. What you wrote in your comment has nothing to do with NiceGUI. This is pyframe specific and is similar to PyWebView's JS API but is considered built using AsyncIO with additional methods and must support Async and Sync.

PyFrame provides you with this method, then later the taskbar menu, shortcut manager and system tray will be added.

Methods for WindowBuilder

These methods are used to configure and initialize a WindowBuilder. They can be initialized recursively if desired.

• with_always_on_bottom()
• with_always_on_top()
• with_closable()
• with_content_protection()
• with_decorations()
• with_focused()
• with_fullscreen()
• with_inner_size()
• with_inner_size_constraints()
• with_max_inner_size()
• with_maximizable()
• with_maximized()
• with_min_inner_size()
• with_minimizable()
• with_position()
• with_resizable()
• with_theme()
• with_title()
• with_transparent()
• with_visible()
• with_visible_on_all_workspaces()
• with_window_icon()

Methods for Window

These methods can be called on a Window instance via TCP.

• available_monitors()
• current_monitor()
• cursor_position()
• drag_resize_window()
• drag_window()
• fullscreen()
• id()
• inner_position()
• inner_size()
• is_closable()
• is_decorated()
• is_focused()
• is_maximizable()
• is_maximized()
• is_minimizable()
• is_minimized()
• is_resizable()
• is_visible()
• monitor_from_point()
• outer_position()
• outer_size()
• primary_monitor()
• request_redraw()
• request_user_attention()
• scale_factor()
• set_always_on_bottom()
• set_always_on_top()
• set_closable()
• set_content_protection()
• set_cursor_grab()
• set_cursor_icon()
• set_cursor_position()
• set_cursor_visible()
• set_decorations()
• set_focus()
• set_fullscreen()
• set_ignore_cursor_events()
• set_ime_position()
• set_inner_size()
• set_inner_size_constraints()
• set_max_inner_size()
• set_maximizable()
• set_maximized()
• set_min_inner_size()
• set_minimizable()
• set_minimized()
• set_outer_position()
• set_progress_bar()
• set_resizable()
• set_title()
• set_visible()
• set_visible_on_all_workspaces()
• set_window_icon()
• theme()
• title()

Methods for WebViewBuilder

These methods are used to configure and initialize a WebViewBuilder. They can also be initialized recursively if desired.

• with_accept_first_mouse()
• with_asynchronous_custom_protocol()
• with_autoplay()
• with_back_forward_navigation_gestures()
• with_background_color()
• with_bounds()
• with_clipboard()
• with_devtools()
• with_document_title_changed_handler()
• with_download_completed_handler()
• with_download_started_handler()
• with_drag_drop_handler()
• with_focused()
• with_headers()
• with_hotkeys_zoom()
• with_html()
• with_incognito()
• with_initialization_script()
• with_navigation_handler()
• with_new_window_req_handler()
• with_on_page_load_handler()
• with_proxy_config()
• with_transparent()
• with_url()
• with_url_and_headers()
• with_user_agent()
• with_visible()
• with_web_context()

Methods for WebView

These methods can be called on a WebView instance via TCP.

• bounds()
• clear_all_browsing_data()
• close_devtools()
• evaluate_script()
• evaluate_script_with_callback()
• focus()
• is_devtools_open()
• load_url()
• load_url_with_headers()
• open_devtools()
• print()
• set_background_color()
• set_bounds()
• set_visible()
• url()
• zoom()

[AriBermeki]

@rodja

[AriBermeki]

as shown here

dsdfdfsd.mp4

[AriBermeki]

Data Flow

[AriBermeki]

Python Version

bbgg.mp4

[rodja]

I guess your feature request is to replace pywebview with some sort of Rust implementation. Have you already such a Rust library? Are you experimenting with one? Where is the source code? Could you please elaborate in clear sentences what you need at this point from NiceGUI?

[AriBermeki]

what do you all mean?

[AriBermeki]

PyFrame provides you with several methods to manipulate different things in the window, all using asyncio. Later, the taskbar menu, shortcut manager and system tray will be added

[AriBermeki]

I would like to ask you to find a way to implement similar functionality to your time and event handlers and your outbox. In addition, it would be helpful to develop some methods you might need later for NiceGUI in PyFrame, even though I don't know their exact requirements yet.

[radu-bors]

Hi, sorry to jump in like this out of nowhere. I'm a colleague of @AriBermeki and can try to explain a bit better what he means. Ari has developed a native window framework called Pyframe. The framework communicates with the operating system web engine and supports asyncio . It only uses Python to start and communicate with the frontend.

Nicegui uses a json based protocol which is sent to Javascript which in turn creates all components recursively. Pyframe does the same as Nicegui, it creates a json based log that is sent to Rust which in turn creates the webview based window. It basically replaces Javascript with Rust.

This framework can also be integrated into NiceGUI, which Ari plans to do. His problem is that he needs functions similar to the ones used in NiceGUI library (the outbox, the event handler and the timer) but not with SocketIO. The framework we are talking about requires TCP. So the question is whether you would be willing and able to help my friend customize the NiceGUI code to work with TCP. This would pave the way to make his work compatible with yours.

[rodja]

Ok makes sense, thanks for the clarifications @AriBermeki. As I said before, we can not commit to something which we do not know. Therefore I suggest:

1. you release PyFrame as a stand alone open source project.
2. gain some community traction (fix bugs, get external contributions, some stars, ...)
3. create a draft pull request showing minimal integration with NiceGUI. This will help us to determine if it's really better than the existing PyWebview solution.
4. if the benefits outweigh problems like a breaking API for all native apps, a custom socketio implementation, required maintenance effort etc. we can think about releasing it in 3.0, 4.0, or similar

[AriBermeki]

Hi @rodja I would like to know where the native GUI should support asyncio. There are problems with native GUIs that might answer your question.

Is your problem with pywebview that the main thread is blocked?

Please tell me explicitly where you want asyncio to work and what exactly is the problem you have with pywebview.

I have been working on this framework for several months, there are problems with native GUIs that no one can help you with because of the native API interfaces.

[AriBermeki]

Here's an example

Aufzeichnung.2025-02-14.233631.mp4

[rodja]

I would like to know where the native GUI should support asyncio.
Please tell me explicitly where you want asyncio to work and what exactly is the problem you have with pywebview.

Pywebview needs to run in it's own process because it otherwise blocks execution. That makes interaction with it complicated: getting/setting window size, updating title etc always needs inter-process communication (which we do with two multiprocessing.Queue objects. It would be perfect if we could simply communicate with the window via async calls.