Ongoing

TLiquid — Open-Source LLM Menu-Bar Translator for macOS

Creator & Sole Developer · 2026 · Ongoing side project · 1 person · 5 min read

Designed, built, and shipped a native-feeling macOS menu-bar translation utility from scratch — live at tliquid.app with public releases, open source under MIT, built with Rust (Tauri 2) and Svelte 5

Overview

TLiquid is a tiny, open-source, bring-your-own-key (BYOK) LLM translator that lives in the macOS menu bar. Select text anywhere, press a global hotkey, and the translation appears instantly — press Enter to copy. It is a system utility, not a chat app: it runs in the background, routes requests directly from the user's machine to their configured LLM provider (OpenAI, Anthropic, Gemini, or OpenRouter), sends no translation text through any intermediary server, and has zero telemetry.

Problem

Existing translation workflows on macOS are clunky for people who work across languages all day: web translators require context switching and paste-copy round trips, native apps are either paid subscriptions or route text through third-party servers, and LLM chat apps are overkill for a two-second translation task. I wanted translation to feel like a system feature — select, hotkey, done — while keeping full control over which model handles the text and guaranteeing nothing leaves the machine except the direct call to the user's own provider.

Constraints

  • Solo project built alongside a full-time job — scope had to be ruthlessly cut to a macOS-first Phase 0 MVP
  • Privacy as a hard requirement: no backend, no telemetry, no translation text touching any server I operate
  • No paid Apple Developer account — the app ships unsigned, so Gatekeeper friction had to be addressed through clear documentation rather than notarization
  • Menu-bar utilities must feel instant and invisible — startup time, memory footprint, and hotkey latency all had to stay minimal

Approach

I built the app on Tauri 2 with a Rust core and a Svelte 5 + TypeScript frontend. The Rust side owns the system integration: tray icon, global shortcut registration, clipboard access, and logging via Tauri's plugin ecosystem. Translation requests go straight from the client to the user's configured provider using their own API key (BYOK), which eliminates the need for any server infrastructure. I shipped early and iterated in public — four releases in the first week — and put up a landing page at tliquid.app with direct .dmg downloads alongside the GitHub releases.

Key Decisions

Built on Tauri 2 (Rust) instead of native Swift/SwiftUI

Reasoning:

Tauri gives a small binary, low memory usage, and first-class plugin support for the exact system features the app needs (tray icon, global shortcuts, clipboard), while keeping the architecture portable for future Windows/Linux phases. A Rust core also made the system-integration layer robust without giving up web-stack iteration speed in the UI.

Alternatives considered:
  • Native Swift/SwiftUI menu-bar app — best-in-class macOS integration, but locks the codebase to one platform
  • Electron — familiar stack, but memory footprint and startup time are unacceptable for an always-running background utility

Bring-your-own-key (BYOK) with direct client-to-provider requests instead of a hosted backend

Reasoning:

Routing translations through my own server would create running costs, a privacy liability, and a trust barrier. With BYOK, users pay their provider directly, choose their model (OpenAI, Anthropic, Gemini, or OpenRouter), and can verify in the open-source code that no text goes anywhere else. No telemetry is a feature, not a compromise.

Alternatives considered:
  • Hosted proxy with subscription pricing — recurring revenue but recurring costs, plus custody of user text
  • On-device models — maximum privacy but noticeably worse translation quality for the size that fits a background utility

Shipped unsigned rather than waiting for Apple notarization

Reasoning:

Signing requires a paid Apple Developer account the project doesn't have yet. Rather than blocking the release, I shipped the unsigned .dmg with explicit, version-specific Gatekeeper instructions (System Settings → Privacy & Security → Open Anyway) in the README and on the landing page. Shipping and getting real users beat waiting for polish.

Alternatives considered:
  • Delay release until notarization was in place
  • Distribute through Homebrew only, sidestepping the .dmg experience

Tech Stack

  • Rust
  • Tauri 2
  • Svelte 5
  • TypeScript
  • Vite
  • LLM APIs (OpenAI, Anthropic, Gemini, OpenRouter)

Result & Impact

  • Live at tliquid.app with public .dmg releases for Apple Silicon
    Status
  • 4 versions shipped in the first week (v0.1.0 → v0.2.0)
    Releases
  • Zero telemetry, zero servers — all requests go directly to the user's own LLM provider
    Privacy

TLiquid took an idea from PRD to a live, downloadable product as a solo effort: product spec, architecture, Rust system integration, UI, landing page, and release engineering. It demonstrates end-to-end ownership of a shipped desktop product — including the unglamorous parts like Gatekeeper documentation, release packaging, and a public roadmap.

Learnings

  • Shipping a desktop utility is 20% core feature and 80% system integration — global shortcuts, clipboard behavior, tray lifecycle, and OS security friction consumed most of the engineering time
  • BYOK is a powerful architecture for indie tools: it removes server costs and privacy liability simultaneously, and turns 'no telemetry' into a verifiable claim because the code is open
  • Cutting scope to macOS-only (and even Apple Silicon-only builds) was what made shipping possible — a portable architecture preserves the future without paying its cost today
  • Distribution friction is a real product surface: clear Gatekeeper instructions for an unsigned app matter as much as the feature set

Technical Deep Dive

The interaction model is the whole product: select text in any app, press the global hotkey, read the translation, press Enter to copy. Everything in the architecture serves the goal of making that loop feel instant and invisible.

The Rust/Tauri core handles the system-level work. Tauri 2’s plugin ecosystem covers the essentials — global-shortcut for the system-wide hotkey, clipboard-manager for reading the selection and writing the result, tray-icon support via the macOS private API feature flag for a proper menu-bar presence. The Svelte 5 frontend renders the compact translation popup and settings, keeping the UI layer thin and fast to iterate on.

Translation requests are built and sent client-side to whichever provider the user configures. Supporting four providers (OpenAI, Anthropic, Gemini, OpenRouter) behind one interface meant normalizing their request/response shapes, streaming behaviors, and error modes — a small taste of the integration work I do professionally, applied to a product I fully own.

The project is open source under MIT, with the full product spec (PRD) and roadmap public in the repository. Phase 0 is deliberately macOS-only; the Tauri architecture keeps Windows and Linux on the table for later phases without paying their cost now.

Links: tliquid.app · GitHub

All projects