# How the Rust Backend in Tauri Handles Window Management Commands in Coco

> Discover how the Rust backend in Tauri manages window commands, mapping actions to platform-specific OS APIs for seamless control within your app. Explore the `Action` enum and `perform_action` dispatch.

- Repository: [INFINI Labs/coco-app](https://github.com/infinilabs/coco-app)
- Tags: internals
- Published: 2026-03-04

---

**The Rust backend in Tauri handles window management commands by exposing Tauri commands that map to an `Action` enum, which `perform_action` dispatches to platform-specific backends using native OS APIs.**

The **Coco** application by Infinilabs uses a Tauri-based desktop architecture where TypeScript frontend code needs precise control over window behavior. When you call methods like `setWindowSize` or `hideWindow` from the frontend, the **Rust backend in Tauri** processes these requests through a structured extension system. This article examines the complete flow from TypeScript invocation to native OS window manipulation.

## Frontend to Backend Communication Flow

The frontend communicates with the Rust backend through Tauri's command invocation system. TypeScript adapters wrap the Tauri API and forward requests to specific command handlers registered in the Rust extension.

### TypeScript Adapter Layer

The frontend uses [`tauriAdapter.ts`](https://github.com/infinilabs/coco-app/blob/main/tauriAdapter.ts) and [`windowService.ts`](https://github.com/infinilabs/coco-app/blob/main/windowService.ts) to abstract window operations:

```typescript
// src/utils/tauriAdapter.ts → src/commands/windowService.ts
await windowAdapter.setWindowSize(800, 600);  // invokes 'set_window_logical_size'
await windowAdapter.hideWindow();             // invokes 'hide_window'

```

Each method calls `invoke()` with a command string that matches the Rust command handler name.

### Command Mapping

The following table maps frontend methods to their corresponding Rust command handlers in [`src-tauri/src/extension/built_in/window_management/mod.rs`](https://github.com/infinilabs/coco-app/blob/main/src-tauri/src/extension/built_in/window_management/mod.rs):

| Frontend Method | Rust Command | Purpose |
|----------------|--------------|---------|
| `setWindowSize` | `set_window_logical_size` | Resizes window to logical pixels |
| `setWindowResizable` | `set_window_resizable` | Toggles resize capability |
| `setWindowFullscreen` | `set_window_fullscreen` | Toggles fullscreen mode |
| `setWindowPosition` | `set_window_logical_position` | Moves window coordinates |
| `hideWindow` / `showWindow` | `hide_window` / `show_window` | Controls window visibility |

## Rust Extension Architecture and Command Registration

The **Window Management** extension registers all window-related commands during Tauri application initialization. This occurs in [`src-tauri/src/lib.rs`](https://github.com/infinilabs/coco-app/blob/main/src-tauri/src/lib.rs), which calls the extension's registration function.

### Extension Entry Point

In [`src-tauri/src/extension/built_in/window_management/mod.rs`](https://github.com/infinilabs/coco-app/blob/main/src-tauri/src/extension/built_in/window_management/mod.rs), the extension defines its identifier and registers command handlers:

```rust
pub(crate) const EXTENSION_ID: &str = "Window Management";

pub(crate) fn register_commands(app: &mut tauri::App) {
    // Registers commands like set_window_logical_size, hide_window, etc.
    // with the Tauri invoke handler
}

```

The `register_commands` function ensures that when the frontend invokes `hide_window` or `set_window_logical_size`, Tauri routes these calls to the appropriate Rust functions.

## Action Enum and Dispatch Logic

Each command handler transforms its parameters into a strongly-typed **`Action`** enum variant. The `perform_action` function serves as the central dispatcher, matching each variant and delegating to platform-specific implementations.

### The Action Enum

Commands are normalized into an internal `Action` enum defined in [`mod.rs`](https://github.com/infinilabs/coco-app/blob/main/mod.rs):

```rust
enum Action {
    SetLogicalSize { width: f64, height: f64 },
    SetResizable { resizable: bool },
    SetFullscreen { enable: bool },
    SetLogicalPosition { x: f64, y: f64 },
    HideWindow,
    ShowWindow,
    // ... additional variants
}

```

### The perform_action Dispatcher

The `perform_action` function in [`src-tauri/src/extension/built_in/window_management/mod.rs`](https://github.com/infinilabs/coco-app/blob/main/src-tauri/src/extension/built_in/window_management/mod.rs) (around line 55) handles the routing:

```rust
fn perform_action(action: Action) -> Result<(), Error> {
    match action {
        Action::SetResizable { resizable } => {
            #[cfg(target_os = "macos")]
            backend::macos::set_resizable(resizable)?;
            #[cfg(target_os = "windows")]
            backend::windows::set_resizable(resizable)?;
            #[cfg(target_os = "linux")]
            backend::linux::set_resizable(resizable)?;
            Ok(())
        }
        Action::HideWindow => {
            #[cfg(target_os = "macos")]
            backend::macos::hide_window()?;
            // ... platform-specific implementations
            Ok(())
        }
        // ... other variants
    }
}

```

This architecture ensures that the **Rust backend in Tauri** maintains clean separation between the command interface and OS-specific window manipulation logic.

## Platform-Specific Backend Implementations

The actual window manipulation occurs in platform-specific modules under `src-tauri/src/extension/built_in/window_management/backend/`. Each implementation uses native OS APIs to interact with the windowing system.

### macOS Implementation

The macOS backend in [`backend/mod.rs`](https://github.com/infinilabs/coco-app/blob/main/backend/mod.rs) uses **CoreGraphics** and **Accessibility APIs** (`CGS*`, `AXUIElement*`) to manipulate the frontmost window:

```rust
// src-tauri/src/extension/built_in/window_management/backend/mod.rs
pub fn set_frontmost_window_frame(frame: CGRect) -> Result<(), Error> {
    // Uses CGSSetWindowBounds and accessibility APIs
    // Line 635 in backend/mod.rs
}

pub fn toggle_fullscreen() -> Result<(), Error> {
    // Calls native CGS API to toggle fullscreen
    // Line 683 in backend/mod.rs
}

pub fn set_resizable(resizable: bool) -> Result<(), Error> {
    // Modifies window style masks via NSWindow APIs
}

```

### Windows Implementation

The Windows backend utilizes the **Win32 API** through the `windows` crate, calling functions like `SetWindowPos` and modifying window styles via `GWL_STYLE`:

```rust
#[cfg(target_os = "windows")]
mod windows {
    use windows::Win32::UI::WindowsAndMessaging::*;
    
    pub fn set_resizable(resizable: bool) -> Result<(), Error> {
        // Retrieves HWND and modifies WS_THICKFRAME style
        // Calls SetWindowPos to apply changes
    }
}

```

### Linux Implementation

The Linux backend handles both **X11** and **Wayland** environments, using `x11rb` for X11 connections or direct Wayland protocol calls:

```rust
#[cfg(target_os = "linux")]
mod linux {
    pub fn set_resizable(resizable: bool) -> Result<(), Error> {
        // Detects display server (X11 vs Wayland)
        // X11: Uses x11rb to send ConfigureWindow requests
        // Wayland: Uses xdg_shell protocol
    }
}

```

## Step-by-Step Execution Flow

To understand exactly how the **Rust backend in Tauri** processes a window resize request, follow this complete execution path:

1. **Frontend Invocation**: TypeScript calls `windowAdapter.setWindowSize(800, 600)`, which executes `invoke('set_window_logical_size', {width: 800, height: 600})`.

2. **Tauri Routing**: Tauri's invoke handler routes the command to the registered handler in [`src-tauri/src/extension/built_in/window_management/mod.rs`](https://github.com/infinilabs/coco-app/blob/main/src-tauri/src/extension/built_in/window_management/mod.rs).

3. **Action Creation**: The command handler constructs `Action::SetLogicalSize { width: 800.0, height: 600.0 }`.

4. **Dispatch**: The handler calls `perform_action(action)`, which matches the `SetLogicalSize` variant.

5. **Platform Selection**: `perform_action` uses conditional compilation (`#[cfg(target_os = "macos")]`) to select the appropriate backend.

6. **Native Execution**: On macOS, `backend::macos::set_frontmost_window_frame()` calls CoreGraphics APIs (`CGSSetWindowBounds`) to resize the actual window.

7. **Response**: The result propagates back through the stack to the TypeScript promise resolver.

## Summary

- The **Rust backend in Tauri** exposes window management through a dedicated extension at `src-tauri/src/extension/built_in/window_management/`.
- **TypeScript** code in [`src/utils/tauriAdapter.ts`](https://github.com/infinilabs/coco-app/blob/main/src/utils/tauriAdapter.ts) invokes commands that map to Rust handlers like `set_window_logical_size` and `hide_window`.
- The **Action** enum normalizes all window operations, with `perform_action` dispatching to platform-specific backends.
- **Platform backends** in [`backend/mod.rs`](https://github.com/infinilabs/coco-app/blob/main/backend/mod.rs) use native APIs: CoreGraphics/Accessibility for macOS, Win32 for Windows, and X11/Wayland for Linux.
- This architecture ensures consistent window behavior across operating systems while maintaining type safety and clean separation of concerns.

## Frequently Asked Questions

### How does the frontend communicate with the Rust backend for window operations?

The frontend uses Tauri's `invoke` function to call registered commands. In [`src/utils/tauriAdapter.ts`](https://github.com/infinilabs/coco-app/blob/main/src/utils/tauriAdapter.ts), methods like `setWindowSize` invoke command strings such as `set_window_logical_size`, which Tauri routes to the corresponding Rust handler in [`src-tauri/src/extension/built_in/window_management/mod.rs`](https://github.com/infinilabs/coco-app/blob/main/src-tauri/src/extension/built_in/window_management/mod.rs).

### What is the purpose of the Action enum in the Rust backend?

The **Action** enum serves as an internal protocol that normalizes all window management requests into strongly-typed variants like `SetLogicalSize`, `SetResizable`, or `HideWindow`. This allows the `perform_action` dispatcher to handle platform-specific implementations cleanly without duplicating command logic across multiple handler functions.

### Which native APIs does the Rust backend use for window management on macOS?

On macOS, the backend in [`src-tauri/src/extension/built_in/window_management/backend/mod.rs`](https://github.com/infinilabs/coco-app/blob/main/src-tauri/src/extension/built_in/window_management/backend/mod.rs) uses **CoreGraphics** APIs (such as `CGSSetWindowBounds`) and **Accessibility** APIs (`AXUIElement*`) to locate and manipulate the frontmost window. These private APIs provide precise control over window geometry and visibility states.

### How does the backend handle different operating systems?

The Rust backend uses conditional compilation with `#[cfg(target_os = "macos")]`, `#[cfg(target_os = "windows")]`, and `#[cfg(target_os = "linux")]` to select the appropriate implementation. Each platform has its own submodule in `backend/` that implements the same interface using native windowing APIs: Win32 for Windows, and X11/Wayland protocols for Linux.