Fix: Linux startup panic from unrealized dictate window (#680)

[PhamBit]

Summary

Fixes a startup crash on Linux where the app opens the main window and then immediately aborts with a non-unwinding panic from tao:

thread 'main' panicked at tao-0.34.5/src/platform_impl/linux/event_loop.rs:449:18:
called `Option::unwrap()` on a `None` value
...
panic in a function that cannot unwind

This is the crash reported in #680.

Root cause

build_dictate_window (in tauri/src-tauri/src/main.rs) constructs the transparent "dictate pill" overlay with .visible(false). On the Linux GTK3 backend, a window that is never shown never has its underlying GDK window realized. Shortly after startup, the first set_ignore_cursor_events() toggle is dispatched over the glib main-context channel and reaches into that unrealized window — tao calls .unwrap() on the None GDK window (event_loop.rs:449) and, because it happens in a non-unwinding context, the panic takes the whole process down before the UI is usable.

Fix

Build the pill visible so GTK realizes the GDK backing, then immediately move it off-screen (-10000, -10000) and hide() it. The pill is still not visible to the user until a speak, so behaviour is unchanged — but the window now actually exists when cursor-ignore is first toggled, so there is no None to unwrap.

The change is confined to build_dictate_window; no public API or other call sites are touched.

Testing

• Environment: Ubuntu 24.04, x86_64, X11 / GTK3 (WebKitGTK), tao 0.34.5 / tauri 2.9.5 — the same stack as [Linux] run just dev crashed on startup with Option::unwrap() panic in tao event loop #680.
• Before: app aborted on every launch at event_loop.rs:449.
• After: app launches and stays up. Verified with xwininfo that both the main window (1200x800) and the dictate pill are realized, with the pill parked off-screen and hidden as intended.
• cargo check --no-default-features passes on current main (only pre-existing keyboard_layout.rs dead-code warnings).

Happy to add a CHANGELOG.md entry in whatever format you prefer.

Fixes #680

Summary by CodeRabbit

• Bug Fixes
  • Improved Linux window handling so the dictate window initializes reliably without crashing when cursor-related events are toggled.
  • Kept the window hidden and off-screen until it is ready to be shown, preventing unintended interaction during startup.

[coderabbitai]

📝 Walkthrough

Walkthrough

The build_dictate_window function in the Tauri desktop backend was modified to create the dictate window visible at construction (instead of hidden), then explicitly reposition it off-screen and hide it after monitor-based positioning logic runs.

Changes

Dictate Window Realization Fix

Layer / File(s)	Summary
Window creation and off-screen parking tauri/src-tauri/src/main.rs	Window builder now sets .visible(true) at creation (with rationale comments for Linux/GTK realization) instead of .visible(false), and after monitor positioning logic, explicitly calls set_position(-10_000, -10_000) and hide() to park the window off-screen and non-interactive.

Estimated code review effort: 2 (Simple) | ~10 minutes

Sequence Diagram(s)

sequenceDiagram
  participant App
  participant WindowBuilder
  participant GdkWindow

  App->>WindowBuilder: build_dictate_window()
  WindowBuilder->>GdkWindow: create with visible(true)
  GdkWindow-->>WindowBuilder: window realized
  WindowBuilder->>GdkWindow: set_position(-10000, -10000)
  WindowBuilder->>GdkWindow: hide()
  GdkWindow-->>App: parked, non-interactive

Loading

Related issues: #680 — Fixes the Linux startup crash caused by Option::unwrap() panic in the tao event loop by ensuring the dictate window's GDK window is realized before later show/hide logic runs.

Suggested labels: bug, linux, tauri

Suggested reviewers: jamiepine

🐰 A window once hidden, now blinks awake,
Then scurries off-screen, no crash in its wake,
GDK realized, GTK appeased,
Linux devs' startup panics, eased.

🚥 Pre-merge checks | ✅ 5

✅ Passed checks (5 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly matches the main change: fixing the Linux startup panic caused by the unrealized dictate window.
Linked Issues check	✅ Passed	The change addresses #680 by realizing the dictate window on Linux and preventing the tao startup panic while keeping the app usable.
Out of Scope Changes check	✅ Passed	The PR is narrowly scoped to the Linux dictate-window startup fix in main.rs with no obvious unrelated changes.
Docstring Coverage	✅ Passed	No functions found in the changed files to evaluate docstring coverage. Skipping docstring coverage check.

✨ Finishing Touches

🧪 Generate unit tests (beta)

• Create PR with unit tests

Warning

Tools execution failed with the following error:

Failed to run tools: 13 INTERNAL: Received RST_STREAM with code 2 (Internal server error)

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[coderabbitai]

🧹 Nitpick comments (1)

tauri/src-tauri/src/main.rs (1)

49-58: 🎯 Functional Correctness | 🔵 Trivial | ⚡ Quick win

Scope the visibility workaround to Linux only.

The rationale comment explains this is a Linux/GTK3/tao-specific realization issue, but .visible(true) is applied unconditionally on all platforms. macOS/Windows previously built the window hidden with no crash; forcing it visible there now introduces an unnecessary (if brief) on-screen flash/focus-steal of the transparent pill before it's parked off-screen at line 70-71.

Consider gating this behind cfg(target_os = "linux") so macOS/Windows retain the original hidden-at-create behavior while Linux gets the realization fix.

♻️ Suggested platform-gated builder

-    .shadow(false)
-    // On Linux (GTK3 + tao 0.34.5), building the transparent dictate pill with
-    // `.visible(false)` leaves its GDK window unrealized. The first
-    // `set_ignore_cursor_events()` dispatched over the glib main-context channel
-    // then unwraps a `None` GDK window and aborts the whole app with a
-    // non-unwinding panic at tao event_loop.rs:449 (see `#680`). Build the window
-    // visible so GTK realizes the GDK backing, then immediately park it
-    // off-screen and hide it (below). Net user-visible effect is unchanged — the
-    // pill stays hidden until a speak — but the window now actually exists.
-    .visible(true)
+    .shadow(false)
+    // On Linux (GTK3 + tao 0.34.5), building the transparent dictate pill with
+    // `.visible(false)` leaves its GDK window unrealized. The first
+    // `set_ignore_cursor_events()` dispatched over the glib main-context channel
+    // then unwraps a `None` GDK window and aborts the whole app with a
+    // non-unwinding panic at tao event_loop.rs:449 (see `#680`). Build the window
+    // visible so GTK realizes the GDK backing, then immediately park it
+    // off-screen and hide it (below). Net user-visible effect is unchanged — the
+    // pill stays hidden until a speak — but the window now actually exists.
+    // Scoped to Linux since macOS/Windows never hit this GDK realization gap.
+    .visible(cfg!(target_os = "linux"))

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@tauri/src-tauri/src/main.rs` around lines 49 - 58, Scope the
window-visibility workaround to Linux only in the builder chain around the
transparent pill creation. The current `.visible(true)` change in `main` is
Linux/GTK3/tao-specific, so gate it with `cfg(target_os = "linux")` (or
equivalent platform branching) and keep macOS/Windows on the original
hidden-at-create path. Preserve the later off-screen parking and hide logic, but
ensure only Linux forces realization before `set_ignore_cursor_events()` is
used.

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Nitpick comments:
In `@tauri/src-tauri/src/main.rs`:
- Around line 49-58: Scope the window-visibility workaround to Linux only in the
builder chain around the transparent pill creation. The current `.visible(true)`
change in `main` is Linux/GTK3/tao-specific, so gate it with `cfg(target_os =
"linux")` (or equivalent platform branching) and keep macOS/Windows on the
original hidden-at-create path. Preserve the later off-screen parking and hide
logic, but ensure only Linux forces realization before
`set_ignore_cursor_events()` is used.

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: a65602f3-1134-4249-bf39-5031fbee42e2

📥 Commits

Reviewing files that changed from the base of the PR and between e766c7c and ca242d8.

📒 Files selected for processing (1)

• tauri/src-tauri/src/main.rs