What you want

• A real app icon in your dock/taskbar
• Its own window, separate from your browser
• Keyboard shortcuts to open it instantly
• Less memory usage than a Chrome tab

The old way: Electron

• Ships an entire copy of Chrome (~200MB+)
• Hungry for RAM and CPU
• Needs a full JavaScript project to set up
• Every app is its own little browser

The secret sauce

• macOS uses Safari's WebKit engine
• Windows uses Edge's WebView2
• Linux uses WebKitGTK
• No extra browser shipped = tiny binary

Pre-built Apps

Make Your Own

• Any internal tool (Notion, Linear, etc.)
• Any SaaS dashboard
• Your own web app or side project
• Works on macOS, Windows, and Linux

// Rust core (92.5% of codebase)
src-tauri/
  src/
    main.rs         // Entry point
    lib.rs          // Tauri app builder
    util.rs         // Utilities
    app/
      config.rs     // Config structs
      window.rs     // WebView builder
      setup.rs      // Tray & shortcuts
      invoke.rs     // Tauri commands
      menu.rs       // macOS menu bar
    inject/
      style.js      // CSS injection
      event.js      // Keyboard & nav
      component.js  // UI components
      auth.js       // OAuth handling
      custom.js     // User scripts
      theme_refresh.js

// TypeScript CLI (pake-cli)
bin/
  cli.ts          // CLI entry point
  defaults.ts     // Default config
  types.ts        // Type definitions
  dev.ts          // Dev mode
  builders/       // Build orchestration
  helpers/        // Utility helpers
  options/        // CLI arg parsing
  utils/          // General utils

// Config files
src-tauri/
  tauri.conf.json       // Main config
  tauri.macos.conf.json // macOS
  tauri.linux.conf.json // Linux
  tauri.windows.conf.json
  pake.json             // Pake-specific
  Cargo.toml            // Rust deps

Why Tauri, Not Electron?

Platform WebViews

• macOS: WKWebView (WebKit/Safari)
• Windows: WebView2 (Chromium/Edge)
• Linux: WebKitGTK

The entry point is minimal

// main.rs
#![cfg_attr(
    all(not(debug_assertions),
        target_os = "windows"),
    windows_subsystem = "windows"
)]

fn main() {
    app_lib::run()
}

PakeConfig (Rust)

struct PakeConfig {
  windows: Vec<WindowConfig>,
  user_agent: PlatformSpecific<String>,
  system_tray: PlatformSpecific<bool>,
  multi_instance: bool,
  multi_window: bool,
}

struct WindowConfig {
  url: String,
  url_type: String, // "web"|"local"
  hide_title_bar: bool,
  fullscreen: bool,
  resizable: bool,
  dark_mode: bool,
  enable_wasm: bool,
  force_internal_navigation: bool,
  // ... 16 more fields
}

PlatformSpecific<T>

struct PlatformSpecific<T> {
  macos: T,
  linux: T,
  windows: T,
}

impl<T> PlatformSpecific<T> {
  fn get(&self) -> &T {
    // Returns current platform's value
    #[cfg(target_os = "macos")]
    return &self.macos;
    // ...
  }
}

Build Pipeline

fn build_window(
  app: &AppHandle,
  opts: WindowBuildOptions
) {
  // 1. Resolve URL type
  match url_type {
    "web" => WebviewUrl::App(url),
    "local" => WebviewUrl::App(path),
  }

  // 2. Configure user agent
  builder.user_agent(config.user_agent.get());

  // 3. Inject JS scripts (6 files)
  builder.initialization_script(...);

  // 4. Platform-specific setup
  #[cfg(target_os = "macos")]
  builder.title_bar_style(...);

  #[cfg(target_os = "windows")]
  builder.browser_args(proxy, flags);
}

Platform Divergence

• macOS: Title bar styling (overlay vs visible), theme enforcement, certificate handling
• Windows: DPI scaling, proxy via --proxy-server flag, data directories, browser feature flags
• Linux: DMABUF renderer disabled, fullscreen focus workarounds

Anti-Detection

// Browser args include:
"--disable-blink-features=
 AutomationControlled"

Prevents websites from detecting the app as an automated browser.

Injection Order

What gets injected

• Config bridge: Rust config exposed as window.pakeConfig to all JS
• Keyboard shortcuts: Cmd/Ctrl + bracket for nav, zoom, refresh
• Link interception: External links open in system browser
• Context menus: Right-click with download/copy/open options
• Style overrides: Hide browser chrome, adjust padding for title bar
• window.open override: Redirects external URLs through shell plugin

Keyboard Shortcuts

Link Routing Logic

detectAnchorElementClick(e) {
  // Classify the link
  if (isInternal(href))
    return; // navigate normally

  if (isDownloadableFile(href))
    invoke('download_file', href);

  if (target === '_blank')
    shell.open(href); // system browser
}

// window.open is overridden too
window.open = (url) => {
  if (isAuthPopup(url))
    return original(url);
  shell.open(url);
}

What It Hides/Adjusts

• Browser-specific UI elements (scrollbars, headers)
• App-specific chrome on Twitter, ChatGPT, YouTube Music, etc.
• Sidebars and navigation components resized
• Responsive media queries for different window sizes

Title Bar Padding

When hide_title_bar is enabled on macOS, a second stylesheet adds 20-60px top padding to headers and navs so content doesn't hide behind the native traffic lights.

How It Works

// On DOMContentLoaded:
const style = document
  .createElement('style');
style.textContent = `
  /* 400+ lines of CSS */
  .twitter-header { display: none; }
  .chatgpt-sidebar { width: 240px; }
  /* ... */
`;
document.head.appendChild(style);

// Conditional title-bar CSS
if (pakeConfig?.hide_title_bar
    && navigator.platform === 'MacIntel') {
  // Inject padding overrides
}

System Tray

• Menu items: New Window (conditional), Hide, Show, Quit
• Left-click toggles window visibility
• Quit saves window state before exit
• Icon from custom path or built-in fallback
• Platform-specific: enabled on Linux/Windows, disabled on macOS by default

// Tray click handler
if window.is_visible() {
  window.minimize();
} else {
  window.show();
  window.set_focus();
}

Global Shortcuts

• Registers system-wide keyboard hotkey
• Debounced with 300ms throttle via Arc<Mutex<Instant>>
• Toggles window visibility (same as tray click)
• Linux: restores fullscreen when configured

Usage

# Install globally
pnpm install -g pake-cli

# Basic usage
pake https://github.com --name GitHub

# With options
pake https://chat.openai.com \
  --name ChatGPT \
  --icon ./icon.png \
  --width 1200 \
  --height 780 \
  --hide-title-bar \
  --dark-mode \
  --system-tray

Build Pipeline

Window & Display

Features & Security

Platform targets: .deb/.appimage (Linux), .dmg (macOS), .msi (Windows)

Cargo.toml Release Profile

[profile.release]
panic = "abort"      # No unwinding
lto = "thin"         # Link-Time Opt
strip = true         # Remove symbols

Why Each Matters

• panic = "abort" — removes unwinding code (~10-15% savings)
• lto = "thin" — cross-crate optimization while keeping reasonable compile times
• strip = true — removes debug symbols from final binary

Size Comparison

Core Dependencies

Feature Flags

• tray-icon — system tray support
• image-ico + image-png — icon formats
• macos-proxy — macOS proxy config

Build Features

[features]
# Development builds
cli-build = []

# Production builds (default)
custom-protocol = [
  "tauri/custom-protocol"
]
default = ["custom-protocol"]

macOS Specifics

• Custom menu bar (File, Edit, Window, Help)
• Title bar overlay with traffic light positioning
• Theme mode updates via update_theme_mode
• Dock click handler to reopen windows
• Fullscreen exit delays for smooth transitions
• Safari-based user agent string

#[cfg(target_os = "macos")]
builder.title_bar_style(
  TitleBarStyle::Overlay
);

Windows / Linux

• Windows: DPI scaling, proxy via CLI args, WebView2 data dirs, windows_subsystem for no console
• Linux: DMABUF renderer disabled, fullscreen focus fixes, WebKitGTK-specific workarounds

#[cfg(target_os = "linux")]
// Disable DMABUF to prevent rendering
// issues on certain compositors
std::env::set_var(
  "WEBKIT_DISABLE_DMABUF_RENDERER",
  "1"
);

URL Downloads (Rust)

#[tauri::command]
async fn download_file(
  url: String,
  filename: String,
  lang: Option<String>
) -> Result<(), String> {
  // 1. Resolve ~/Downloads path
  // 2. Stream response in chunks
  // 3. Write to disk
  // 4. Show progress toast
  // 5. Send notification on complete
}

Blob/Data URI (JavaScript → Rust)

// event.js handles blob: and data: URIs
if (url.startsWith('blob:')) {
  const reader = new FileReader();
  reader.readAsArrayBuffer(blob);
  reader.onload = () =>
    invoke('download_file_by_binary', {
      binary: Array.from(
        new Uint8Array(result)
      )
    });
}

if (url.startsWith('data:')) {
  // Decode base64 → binary
  // Send to Rust via IPC
}

Tauri Security Layers

Pake's Security Choices

• No CSP configured (null) — relies on site's own CSP
• Incognito mode option — no persistent cookies/storage
• Certificate error handling — configurable per platform
• Navigation guard — on_navigation handler filters allowed domains
• Anti-automation — disables Blink automation detection flags

Compile-Time Pipeline

Runtime Architecture

Why Pake is Interesting

• Rust + Tauri 2.x as a production-grade Electron alternative
• JS injection as a first-class architectural layer, not a hack
• PlatformSpecific<T> generic for clean cross-platform configs
• Conditional compilation keeps each binary lean
• Plugin architecture for modular native capabilities
• CLI as config generator — writes JSON, then calls Cargo

Patterns Worth Stealing

• Reuse existing OS components (WebView) instead of shipping your own
• Aggressive binary optimization (panic=abort, thin LTO, strip)
• Bridge heavy operations to Rust (downloads), keep UI in JS
• Debounced global shortcuts with Arc<Mutex<Instant>>
• Navigation guards + window.open override for link routing
• Two-path download system (URL streaming vs blob decode)