[Go] webui.Wait() and webui.WaitAsync()... doesn't «wait»

[soulchainer]

Hi.

What I want to achieve

I simply want, in Linux (and it must work on Wayland), to:

1. open an URL in a new browser window
2. Wait for that window to be closed
3. After the window is closed, do some action.

So I guessed I could use WebUI for that. If I use, for example, xdg-open instead of WebUI, then I can't control it to be opened in a new window (most browsers open them in a new tab if there is already a browser open or the one closed has a saved session), neither I can «detect» if the (external) tab/URL (which I do not control) is closed or not.

Sample code

I have this very simple code:

package main

import (
	"fmt"
	"github.com/webui-dev/go-webui/v2"
)


func main() {
	// webui.SetTimeout(0)
	win := webui.NewWindow()
	win.Show("http://webui.me")

	// NEITHER webui.Wait() nor webui.WaitAsync() wait until all windows are closed
	for webui.WaitAsync() {
		fmt.Println("There are open windows, wait.")
	}

	fmt.Println("All windows closed (NOT TRUE).")
}

Expectations VS Reality

According to several examples and documentation too:

wait. Block and wait until all opened windows are closed.
wait_async. A non-blocking alternative to Wait() for use when you need to run code on the main thread between UI events (required in WebView mode). Call it in a loop; it returns false when all windows are closed.

Neither of them do that. What I get with the quoted code:

1. Window opens with the URL
2. It waits a mere seconds...
3. It prints several «There are open windows, wait.» lines
4. In prints, at last, «All windows closed (NOT TRUE).» line.
5. It closes.

It doesn't waits for the only opened window to close.

If I uncomment the commented line // webui.SetTimeout(0) (which, according to documentation, is already the default), then it doesn't run for a few seconds and close, but does an infinity loop. Problem is this way WebUI neither detects whenever the (only opened) window is closed, so such infinity loop... goes infinitely 😅.

Are I doing something wrong. Is this how this is supposed to work? Because that's against what documentation seems to say.

Other Details

• 7.1.8-1-cachyos
• Same Behavior in XFCE (X11) and Hyprland (Wayland)
• Did go get github.com/webui-dev/go-webui/v2@main as README says.
• Ensured to delete previously installed go-webui.

  • go.mod

    module myproject
    
    go 1.26.6
    
    require github.com/webui-dev/go-webui/v2 v2.5.3-0.20260731142231-46adf9765927

  • go.sum

    github.com/webui-dev/go-webui/v2 v2.5.3-0.20260731142231-46adf9765927 h1:bb9MAFAyj7/IPCaaS3SHZdSVbV21Yfwrhu0FUB/YEL4=
    github.com/webui-dev/go-webui/v2 v2.5.3-0.20260731142231-46adf9765927/go.mod h1:wAuoPsuZW60krM633fOFAQFtnRgzFD1dGDRHQd6lfPY=

    But, even so, terminal insists in saying that:

    ❯ go run -tags webui_log main.go
    [User] webui_new_window()
    [User] webui_get_new_window_id()
    [Core]      WebUI v2.5.0-beta.4 (GNU/Linux, GCC, Static, Non-Encrypted)

    So, according to that, I'm using WebUI v2.5.0-beta.4. Is that normal? It shouldn't.

Full terminal log

Initial code, ran in Hyprland):

❯ go run -tags webui_log main.go
[User] webui_new_window()
[User] webui_get_new_window_id()
[Core]      WebUI v2.5.0-beta.4 (GNU/Linux, GCC, Static, Non-Encrypted)
[Core]      _webui_init()
[Core]      _webui_get_current_path()
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x1b1a0040)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1b1a0040) -> Pointer #0 saved (4096 + 1 bytes)
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x1b1a1050)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1b1a1050) -> Pointer #1 saved (4096 + 1 bytes)
[User] webui_new_window_id([1])
[Core]      _webui_malloc([2621968])
[Core]      _webui_ptr_add(0x0x7f42c899b010)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x7f42c899b010) -> Pointer #2 saved (26219681 bytes)
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x1b1a20e0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1b1a20e0) -> Pointer #3 saved (4096 + 1 bytes)
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x1b1a30f0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1b1a30f0) -> Pointer #4 saved (4096 + 1 bytes)
[User] webui_set_center(1)
[Core]      _webui_load_gtk_and_webkit() -> GTK loaded [libgtk-3.so.0]
[Core]      _webui_load_gtk_and_webkit() -> WebKit loaded [libwebkit2gtk-4so.0]
[User] webui_set_center() -> Screen dimensions: width=0, height=0
[User] webui_bind([1])
[Core]      _webui_get_cb_index([1])
[Core]      _webui_get_cb_index() -> Element: [__webui_core_api__]
[Core]      _webui_get_cb_index() -> Not found
[Core]      _webui_free_mem(0x(nil))
[Core]      _webui_malloc([18])
[Core]      _webui_ptr_add(0x0x1b207550)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1b207550) -> Pointer #5 saved (18 + 1 bytes)
[User] webui_bind() -> Save bind index 0, address 0x0x4f30b0
[Core]      _webui_send_all()
[User] webui_new_window_id() -> New window #1 @ 0x0x7f42c899b010
[User] webui_show([1])
[Core]      _webui_show([1])
[Core]      _webui_malloc([15])
[Core]      _webui_ptr_add(0x0x1b57f100)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1b57f100) -> Pointer #6 saved (15 + 1 bytes)
[Core]      _webui_is_valid_url([http://w...])
[Core]      _webui_show() -> URL: [http://webui.me]
[Core]      _webui_show_window(URL, [1])
[Core]      _webui_get_free_port()
[Core]      _webui_port_is_used([37189])
[Core]      _webui_socket_test_listen_mg([37189])
[Core]      _webui_malloc([64])
[Core]      _webui_ptr_add(0x0x1b3d28e0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1b3d28e0) -> Pointer #7 saved (64 + 1 bytes)
[Core]      _webui_malloc([32])
[Core]      _webui_ptr_add(0x0x1b35d4f0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1b35d4f0) -> Pointer #8 saved (32 + 1 bytes)
[Core]      _webui_malloc([79])
[Core]      _webui_ptr_add(0x0x1b3daa80)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1b3daa80) -> Pointer #9 saved (79 + 1 bytes)
[Core]      _webui_browser_start([http://webui.me], [1])
[Core]      _webui_find_the_best_browser()
[Core]      _webui_is_process_running([chrome])
[Core]      _webui_is_process_running([msedge])
[Core]      _webui_is_process_running([vivaldi-bin])
[Core]      _webui_is_process_running([brave])
[Core]      _webui_is_process_running([firefox])
[Core]      _webui_browser_exist([3])
[Core]      _webui_custom_browser_exist([3])
[Core]      _webui_cmd_sync()
[Core]      _webui_cmd_sync() -> Running [firefox -v >>/dev/null 2>>/dev/null]
[Core]      _webui_cmd_sync() -> Command Result [0]
[Core]      _webui_browser_start_firefox([http://webui.me])
[Core]      _webui_browser_exist([3])
[Core]      _webui_browser_create_new_profile(3)
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x1b2f5890)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1b2f5890) -> Pointer #10 saved (4096 +bytes)
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x1b2f4780)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1b2f4780) -> Pointer #11 saved (4096 + 1 bytes)
[Core]      _webui_browser_create_new_profile(3) -> Generating WebUI profile
[Core]      _webui_get_temp_path()
[Core]      _webui_file_exist([~/.mozilla/firefox/profiles.ini])
[Core]      _webui_file_exist() -> Parsed to [/home/soulchainer//.mozilla/firefox/profiles.ini]
[Core]      _webui_folder_exist([/home/soulchainer/snap/firefox/common/.mozilla/firefox/.WebUI/WebUIFirefoxProfile-NoHC])
[Core]      _webui_is_firefox_ini_profile_exist([~/.mozilla/firefox/profiles.ini], [WebUI])
[Core]      _webui_is_firefox_ini_profile_exist() -> Opening [/home/soulchainer//.mozilla/firefox/profiles.ini]
[Core]      _webui_is_firefox_ini_profile_exist() -> Target found
[Core]      _webui_get_browser_args([3])
[Core]      _webui_run_browser()
[Core]      _webui_cmd_async()
[Core]      _webui_cmd_async() -> Running [firefox -P WebUI -purgecaches -new-window http://webui.me >>/dev/null 2>>/dev/null &]
[Core]      _webui_show_window() -> App-mode browser succeeded
[Core]      _webui_free_mem(0x0x1b57f100)
[Core]      _webui_free_mem(0x0x1b57f100) -> Pointer #6 freed (15 + 1 bytes)
[Core]      _webui_show_window() -> Waiting for window connection & token validation
[Core]      _webui_timer_start()
[Core]      _webui_server_thread()
[Core]      _webui_server_thread([1]) -> URL: [http://localhost:37189]
[Core]      _webui_malloc([64])
[Core]      _webui_ptr_add(0x0x7f4278000880)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x7f4278000880) -> Pointer #6 saved (64 + 1 bytes)
[Core]      _webui_server_thread([1]) -> Listening Success
[Core]      _webui_server_thread([1]) -> HTTP/WS Port: 127.0.0.1:37189
[Core]      _webui_server_thread([1]) -> Root path: .
[Core]      _webui_server_thread([1]) -> Timeout is 15 seconds
[Core]      _webui_server_thread([1]) -> Waiting for connection
[Core]      _webui_timer_start()
[Core]      _webui_server_thread([1]) -> Server stopping...
[User] webui_focus([1])
There are open windows, wait.
... # several lines repeating the same message
[Core]      _webui_free_port([37189])
There are open windows, wait.
There are open windows, wait.
[Core]      _webui_free_mem(0x0x7f4278000880)
There are open windows, wait.
There are open windows, wait.
[Core]      _webui_free_mem(0x0x7f4278000880) -> Pointer #6 freed (64 + 1 bytes)
There are open windows, wait.
[Core]      _webui_server_thread([1]) -> Server stopped.
There are open windows, wait.
[Core]      _webui_make_window_reusable(1)
There are open windows, wait.
[Core]      _webui_condition_signal()
[Loop] _webui_wait_clean(Non-Blocking) -> Cleaning...
[Loop] _webui_wait_clean() -> Main loop exit successfully
All windows closed (NOT TRUE).

[kratos0718]

This is working as designed rather than being a bug — Wait() isn't waiting on browser windows, it's waiting on WebUI servers with a connected client, and an external URL never produces one.

The condition the wait loop actually spins on is in webui.c:

static bool _webui_wait_is_needed(void) {
    if (_webui_mutex_app_is_exit_now(WEBUI_MUTEX_GET_STATUS))
        return false;
    return _webui_mutex_is_more_servers_running();
}

WebUI knows a window has closed because the page it served loads webui.js, which holds a WebSocket back to the local server; the close is observed in _webui_ws_close_handler. When you call Show("http://webui.me") the content is classified as WEBUI_SHOW_URL and the browser simply navigates to a third-party site. That page doesn't load webui.js, so no client ever connects, no server stays running, _webui_mutex_is_more_servers_running() is false, and Wait() returns straight away. WaitAsync() returns false for the same reason, which is why your loop exits immediately.

SetTimeout(0) won't change this either — it removes the start-up deadline for a client to connect, it doesn't make WebUI track a page it has no channel to.

What to use instead, given your goal. Show it in WebUI's own WebView rather than an external browser:

win := webui.NewWindow()
win.ShowWv("http://webui.me")   // webui_show_wv() in the C API
webui.Wait()

webui_show_wv() sets allow_browser = false; allow_webview = true, so the window is a native GTK/WebKit window that WebUI itself owns. Closing it fires _webui_wv_event_closed, which is a real close signal independent of the JS bridge — exactly the "wait until the user closes it" semantics you're after, and it works under Wayland since it's a normal GTK window.

If the Go binding you're on doesn't expose ShowWv, it's webui_show_wv(size_t window, const char* content) in the C header and trivially cgo-able.

If it must be the user's real browser, WebUI can't help you — detection fundamentally requires that JS bridge, and you don't control webui.me. The usual approach there is to launch the browser yourself and wait on the process, forcing a fresh instance so it doesn't hand the URL to an already-running one and exit immediately:

cmd := exec.Command("firefox", "--new-instance", "--profile", tmpProfile, "http://webui.me")
cmd.Start()
cmd.Wait()   // returns when that browser instance exits

The separate profile is the important part — without it firefox/google-chrome hands off to the existing process and returns instantly, which is the same class of problem you're hitting now. For Chrome the equivalent is --user-data-dir=/tmp/whatever.

[kratos0718]

That log is good news, actually — the WebView route is the right one for you, and what's failing isn't WebUI.

Look at where it dies:

[Core]  _webui_wv_show() -> Return [1]
[Core]  _webui_show_window() -> WebView Found
[Core]  _webui_wv_event_title()
Failed to create GBM buffer of size 800x600: Argumento inválido
[Core]  _webui_webview_update(1)
[Core]  [Thread .] _webui_webview_thread() -> Cleaning

WebUI got as far as creating the window and setting its title — _webui_wv_show() returned 1, i.e. success. The GBM error comes from WebKitGTK, underneath. Since 2.40 it renders through a DMA-BUF path that allocates buffers via GBM, and on a fair number of Wayland setups (NVIDIA proprietary, VMs, some hybrid-graphics laptops, containers without the right render node) that allocation fails with exactly Failed to create GBM buffer ... invalid argument. WebUI then sees the webview thread clean itself up and reports failed to show WebView window, which is a truthful but downstream message.

The standard workaround is to turn that renderer off:

WEBKIT_DISABLE_DMABUF_RENDERER=1 go run -tags webui_log main.go

If you'd rather not depend on the caller's environment, set it before the first WebUI call, since GTK/WebKit is initialised lazily on the first show:

func main() {
	os.Setenv("WEBKIT_DISABLE_DMABUF_RENDERER", "1")

	win := webui.NewWindow()
	if err := win.ShowWebView("http://webui.me"); err != nil {
		fmt.Printf("There was an error: %v\n", err)
		return
	}
	webui.Wait()   // now blocks until the window is closed
}

On older WebKitGTK the equivalent knob is WEBKIT_DISABLE_COMPOSITING_MODE=1 — worth trying if the first one doesn't take.

Once the window actually opens, Wait() behaves the way you originally expected: closing it fires _webui_wv_event_closed, which is a genuine window-close signal rather than the WebSocket-based detection that external URLs can never produce. You can see both paths in your own log — the close handler ran on teardown.

On your fallback plan: enumerating $BROWSER and a list of executables is workable, but keep in mind the caveat from before — you'd still need to force a fresh instance (--new-instance --profile ... for Firefox, --user-data-dir=... for Chrome), otherwise the binary hands the URL to the already-running browser and exits immediately, and you're back to a process that returns straight away. If the DMABUF flag fixes the WebView for you, that whole branch goes away.

And your point about the docs stands — "wait until all windows are closed" doesn't hint that it means windows WebUI has a live connection to. That's probably worth a docs issue separately.

[soulchainer]

@kratos0718 I marked this as an answer, but... in my case is inconclusive :( .

It's true that the mentioned env variables solve such problem to a lot of people (I did a bit of time-consuming digging :þ), but it doesn't work for me.

But this have helped me to realice the problem. Simple put, Webkit + Nvidia.
I found a lot of results about this, and all are pointing to that and it comes from far away. It seems that, maybe, from this old Webkit issue or any other :þ. Probably I will spend my time better if I opt for favoring my fallback plan and avoid Webkit entirely. It will be a little more time consuming, initially, but probably (and only probably) I won't have another WebKit issue coming soon. In case I would solve this one with some workaround, probably there would be other people suffering from another one. In fact, I have another piece of software I depend a lot of, which is a Tauri app, also making use of Webkit and Webkit hangs frecuently or have CPU spikes that make me to reset the process (whenever I hear my fans acting weird is this software misbehaving). Looking to replace it too. Just hope Orion Browser won't bring those problems too, because it looked promising...

I will keep WebUI in mind for other stuff. Have a good week, @kratos0718 :). Many thanks again for your help 👍 .

[kratos0718]

Thanks for closing the loop, and for marking it even though it didn't get you all the way — that's generous.

Your read is right: WebKit + NVIDIA is a long-standing pairing problem, and WEBKIT_DISABLE_DMABUF_RENDERER only helps when the failure is in the DMA-BUF path specifically. On the proprietary driver there are several other ways to land on the same GBM allocation error, which is why it fixes it for many people and not for you.

One last thing for the fallback, since I mentioned it in passing but it's the detail that decides whether the approach works at all — the profile flag isn't optional:

cmd := exec.Command("firefox", "--new-instance", "--profile", tmpProfileDir, url)
// chrome/chromium: --user-data-dir=/tmp/whatever
cmd.Start()
cmd.Wait()   // returns when that instance exits

Without --new-instance/--user-data-dir, the binary sees an already-running browser, hands the URL over via IPC, and exits immediately — so cmd.Wait() returns in milliseconds and you get exactly the "doesn't wait" behaviour you started this thread with, just from a different cause. With a dedicated profile you get a real child process whose exit is the signal you want, and no GPU stack involved at all. Given NVIDIA is your constraint, that's arguably the more robust path regardless.

Good luck with it — and if you do end up filing something about the Wait() docs wording, that seems worth doing; "wait until all windows are closed" genuinely doesn't hint that it means windows WebUI holds a connection to.

[soulchainer]

🙇 Thanks for the quick and in depth reply, @kratos0718 .

I understand (a bit more) now... So, Wait wording in documentation is confusing/not specific.

The fact is that I already tried with WebView before (the go binding exposes it as webui.ShowWebView), but

win := webui.NewWindow()
err := win.ShowWebView("http://webui.me")
if err != nil {
	fmt.Printf("There was an error: %v", err)
}
webui.Wait()

makes the program to exit because of a protocol error:

 ❯ go run -tags webui_log main.go
[User] webui_new_window()
[User] webui_get_new_window_id()
[Core]      WebUI v2.5.0-beta.4 (GNU/Linux, GCC, Static, Non-Encrypted)
[Core]      _webui_init()
[Core]      _webui_get_current_path()
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x19cb3040)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x19cb3040) -> Pointer #0 saved (4096 + 1 bytes)
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x19cb4050)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x19cb4050) -> Pointer #1 saved (4096 + 1 bytes)
[User] webui_new_window_id([1])
[Core]      _webui_malloc([2621968])
[Core]      _webui_ptr_add(0x0x7f5bf86db010)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x7f5bf86db010) -> Pointer #2 saved (2621968 + 1 bytes)
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x19cb50e0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x19cb50e0) -> Pointer #3 saved (4096 + 1 bytes)
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x19cb60f0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x19cb60f0) -> Pointer #4 saved (4096 + 1 bytes)
[User] webui_set_center(1)
[Core]      _webui_load_gtk_and_webkit() -> GTK loaded [libgtk-3.so.0]
[Core]      _webui_load_gtk_and_webkit() -> WebKit loaded [libwebkit2gtk-4.1.so.0]
[User] webui_set_center() -> Screen dimensions: width=0, height=0
[User] webui_bind([1])
[Core]      _webui_get_cb_index([1])
[Core]      _webui_get_cb_index() -> Element: [__webui_core_api__]
[Core]      _webui_get_cb_index() -> Not found
[Core]      _webui_free_mem(0x(nil))
[Core]      _webui_malloc([18])
[Core]      _webui_ptr_add(0x0x19d1a550)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x19d1a550) -> Pointer #5 saved (18 + 1 bytes)
[User] webui_bind() -> Save bind index 0, address 0x0x4f3470
[Core]      _webui_send_all()
[User] webui_new_window_id() -> New window #1 @ 0x0x7f5bf86db010
[User] webui_show_wv([1])
[Core]      _webui_show([13])
[Core]      _webui_malloc([15])
[Core]      _webui_ptr_add(0x0x1a0924a0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1a0924a0) -> Pointer #6 saved (15 + 1 bytes)
[Core]      _webui_is_valid_url([http://w...])
[Core]      _webui_show() -> URL: [http://webui.me]
[Core]      _webui_show_window(URL, [13])
[Core]      _webui_get_free_port()
[Core]      _webui_port_is_used([12862])
[Core]      _webui_socket_test_listen_mg([12862])
[Core]      _webui_malloc([64])
[Core]      _webui_ptr_add(0x0x19ee5ca0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x19ee5ca0) -> Pointer #7 saved (64 + 1 bytes)
[Core]      _webui_malloc([32])
[Core]      _webui_ptr_add(0x0x19deb890)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x19deb890) -> Pointer #8 saved (32 + 1 bytes)
[Core]      _webui_malloc([79])
[Core]      _webui_ptr_add(0x0x19eede40)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x19eede40) -> Pointer #9 saved (79 + 1 bytes)
[Core]      _webui_wv_show([http://webui.me])
[Core]      _webui_malloc([15])
[Core]      _webui_ptr_add(0x0x19ee3de0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x19ee3de0) -> Pointer #10 saved (15 + 1 bytes)
[Core]      _webui_malloc([56])
[Core]      _webui_ptr_add(0x0x19ee5cf0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x19ee5cf0) -> Pointer #11 saved (56 + 1 bytes)
[Core]      _webui_wv_create()
Overriding existing handler for signal 10. Set JSC_SIGNAL_FOR_GC if you want WebKit to use a different signal
[Core]      _webui_webview_update(1)
[Core]      _webui_condition_signal()
[Core]      _webui_timer_start()
[Core]      [Thread .] _webui_webview_thread()
[Core]      [Thread .] _webui_webview_thread() -> Started
[Core]      [Thread .] _webui_webview_thread() -> Waiting for WebUI Messages...
[Core]      _webui_wv_show() -> Return [1]
[Core]      _webui_show_window() -> WebView Found
[Core]      _webui_free_mem(0x0x1a0924a0)
[Core]      _webui_free_mem(0x0x1a0924a0) -> Pointer #6 freed (15 + 1 bytes)
[Core]      _webui_show_window() -> Waiting for window connection & token validation
[Core]      _webui_timer_start()
[Core]      _webui_server_thread()
[Core]      _webui_server_thread([1]) -> URL: [http://localhost:12862]
[Core]      _webui_malloc([64])
[Core]      _webui_ptr_add(0x0x7f5b3c0008a0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x7f5b3c0008a0) -> Pointer #6 saved (64 + 1 bytes)
[Core]      _webui_server_thread([1]) -> Listening Success
[Core]      _webui_server_thread([1]) -> HTTP/WS Port: 127.0.0.1:12862
[Core]      _webui_server_thread([1]) -> Root path: .
[Core]      _webui_server_thread([1]) -> Timeout is 15 seconds
[Core]      _webui_server_thread([1]) -> Waiting for connection
[Core]      _webui_timer_start()
[Core]      _webui_wv_event_title()
Gdk-Message: 15:42:19.020: Error 71 (Error de protocolo) dispatching to Wayland display.
exit status 1

So I thought that, in fact, it didn't support Wayland (or it has some bug there) and tried the browser window route.

In XFCE (X11), the same code doesn't return a protocol error, but it opens an empty window (no content), waits a few seconds... and also closes itself (no user interaction):

 ❯ go run -tags webui_log main.go
[User] webui_new_window()
[User] webui_get_new_window_id()
[Core]      WebUI v2.5.0-beta.4 (GNU/Linux, GCC, Static, Non-Encrypted)
[Core]      _webui_init()
[Core]      _webui_get_current_path()
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x16398fc0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x16398fc0) -> Pointer #0 saved (4096 + 1 bytes)
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x16399fd0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x16399fd0) -> Pointer #1 saved (4096 + 1 bytes)
[User] webui_new_window_id([1])
[Core]      _webui_malloc([2621968])
[Core]      _webui_ptr_add(0x0x7f1ce871b010)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x7f1ce871b010) -> Pointer #2 saved (2621968 + 1 bytes)
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x1639afe0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1639afe0) -> Pointer #3 saved (4096 + 1 bytes)
[Core]      _webui_malloc([4096])
[Core]      _webui_ptr_add(0x0x1639bff0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x1639bff0) -> Pointer #4 saved (4096 + 1 bytes)
[User] webui_set_center(1)
[Core]      _webui_load_gtk_and_webkit() -> GTK loaded [libgtk-3.so.0]
[Core]      _webui_load_gtk_and_webkit() -> WebKit loaded [libwebkit2gtk-4.1.so.0]
Gtk-Message: 15:38:44.433: Failed to load module "colorreload-gtk-module"
Gtk-Message: 15:38:44.433: Failed to load module "window-decorations-gtk-module"
[User] webui_set_center() -> Screen dimensions: width=2560, height=1080
[User] webui_set_center() -> Window dimensions: width=800, height=600
[User] webui_set_center() -> Calculated center positions: x=880, y=240
[User] webui_set_position(1, 880, 240)
[User] webui_bind([1])
[Core]      _webui_get_cb_index([1])
[Core]      _webui_get_cb_index() -> Element: [__webui_core_api__]
[Core]      _webui_get_cb_index() -> Not found
[Core]      _webui_free_mem(0x(nil))
[Core]      _webui_malloc([18])
[Core]      _webui_ptr_add(0x0x164004f0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x164004f0) -> Pointer #5 saved (18 + 1 bytes)
[User] webui_bind() -> Save bind index 0, address 0x0x4f3470
[Core]      _webui_send_all()
[User] webui_new_window_id() -> New window #1 @ 0x0x7f1ce871b010
[User] webui_show_wv([1])
[Core]      _webui_show([13])
[Core]      _webui_malloc([15])
[Core]      _webui_ptr_add(0x0x164f11a0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x164f11a0) -> Pointer #6 saved (15 + 1 bytes)
[Core]      _webui_is_valid_url([http://w...])
[Core]      _webui_show() -> URL: [http://webui.me]
[Core]      _webui_show_window(URL, [13])
[Core]      _webui_get_free_port()
[Core]      _webui_port_is_used([29176])
[Core]      _webui_socket_test_listen_mg([29176])
[Core]      _webui_malloc([64])
[Core]      _webui_ptr_add(0x0x164f1150)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x164f1150) -> Pointer #7 saved (64 + 1 bytes)
[Core]      _webui_malloc([32])
[Core]      _webui_ptr_add(0x0x164f6fe0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x164f6fe0) -> Pointer #8 saved (32 + 1 bytes)
[Core]      _webui_malloc([79])
[Core]      _webui_ptr_add(0x0x165c7c60)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x165c7c60) -> Pointer #9 saved (79 + 1 bytes)
[Core]      _webui_wv_show([http://webui.me])
[Core]      _webui_malloc([15])
[Core]      _webui_ptr_add(0x0x164e8db0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x164e8db0) -> Pointer #10 saved (15 + 1 bytes)
[Core]      _webui_malloc([56])
[Core]      _webui_ptr_add(0x0x164f10e0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x164f10e0) -> Pointer #11 saved (56 + 1 bytes)
[Core]      _webui_wv_create()
Overriding existing handler for signal 10. Set JSC_SIGNAL_FOR_GC if you want WebKit to use a different signal
[Core]      _webui_webview_update(1)
[Core]      _webui_condition_signal()
[Core]      _webui_timer_start()
[Core]      [Thread .] _webui_webview_thread()
[Core]      [Thread .] _webui_webview_thread() -> Started
[Core]      [Thread .] _webui_webview_thread() -> Waiting for WebUI Messages...
[Core]      _webui_wv_show() -> Return [1]
[Core]      _webui_show_window() -> WebView Found
[Core]      _webui_free_mem(0x0x164f11a0)
[Core]      _webui_free_mem(0x0x164f11a0) -> Pointer #6 freed (15 + 1 bytes)
[Core]      _webui_show_window() -> Waiting for window connection & token validation
[Core]      _webui_timer_start()
[Core]      _webui_server_thread()
[Core]      _webui_server_thread([1]) -> URL: [http://localhost:29176]
[Core]      _webui_malloc([64])
[Core]      _webui_ptr_add(0x0x7f1c280008a0)
[Core]      _webui_ptr_exist()
[Core]      _webui_ptr_add(0x0x7f1c280008a0) -> Pointer #6 saved (64 + 1 bytes)
[Core]      _webui_server_thread([1]) -> Listening Success
[Core]      _webui_server_thread([1]) -> HTTP/WS Port: 127.0.0.1:29176
[Core]      _webui_server_thread([1]) -> Root path: .
[Core]      _webui_server_thread([1]) -> Timeout is 15 seconds
[Core]      _webui_server_thread([1]) -> Waiting for connection
[Core]      _webui_timer_start()
[Core]      _webui_wv_event_title()
Failed to create GBM buffer of size 800x600: Argumento inválido
Failed to create GBM buffer of size 800x600: Argumento inválido
[Core]      _webui_server_thread([1]) -> Server stopping...
[Core]      _webui_webview_update(1)
[Core]      _webui_condition_signal()
[Core]      [Thread .] _webui_webview_thread() -> Cleaning
[Core]      _webui_wv_close()
[Core]      _webui_wv_close() -> Closing WebView window
[Core]      _webui_free_mem(0x0x164e8db0)
[Core]      _webui_free_mem(0x0x164e8db0) -> Pointer #10 freed (15 + 1 bytes)
[Core]      _webui_free_mem(0x0x164f10e0)
[Core]      _webui_free_mem(0x0x164f10e0) -> Pointer #11 freed (56 + 1 bytes)
[Core]      [Thread .] _webui_webview_thread() -> End
[Core]      _webui_wv_event_on_close()
[Core]      _webui_wv_event_closed()
[User] webui_focus([1])
There was an error: error: failed to show WebView window[Core]      _webui_free_port([29176])
[Core]      _webui_free_mem(0x0x7f1c280008a0)
[Core]      _webui_free_mem(0x0x7f1c280008a0) -> Pointer #6 freed (64 + 1 bytes)
[Core]      _webui_server_thread([1]) -> Server stopped.
[Core]      _webui_make_window_reusable(1)
[Core]      _webui_condition_signal()
[Loop] _webui_wait_clean(Non-Blocking) -> Cleaning...
[Core]      _webui_wv_free()
[Loop] _webui_wait_clean() -> Main loop exit successfully

So, I would prefer to use the Webview indeed, but it doesn't want to work 😢.

Thanks, again, for the suggestion, but I already knew that I could force a specific browser and pass some arguments and all that (I used it before). The point of using WebUI for this was specifically to avoid tying the program to a specific browser, using the general functions and let WebUI deal finding «the best browser» for that.

But if the WebView doesn't work... I guess I would need to check for the existance of the common environment variable BROWSER and make an ordered list of suitable browsers (which can even have different executable names in different distributions), with the args needed for each option, check if such executables are in path and run the BROWSER one if available or one from such list (from more to less suitable). In the bright side of things, that would mean one external dependency less 😀.

[AlbertShown]

Thank you for reporting that. I tried to reproduce the issue in many distros, but it always works just fine on my nVidia GPU machine.

• Ubuntu 22 Gnome
• Ubuntu 26 Gnome
• Ubuntu 26 KDE Plasma Wayland, just like CachyOS

I think this issue is a GPU driver or graphics rendering issue, not a WebUI bug.

nVidia drivers on Linux do not guarantee stability, unfortunately.