Quaka is a React front end talking to a Rust back end through a desktop shell. The specific numbers that made the case: a 3.8MB install against roughly 165MB for a comparable Electron build, 25 to 40MB of idle memory against 90 to 180MB, and a permission system that lives in code rather than in the UI.
What a coding agent needs from a desktop shell
Most desktop apps just need a window. An agent needs considerably more: to run arbitrary shell commands with a timeout, read and write files across a repository, hold API credentials, stream responses over HTTP, and refuse to do any of those things when a mode says no. That is a security surface, not a rendering surface.
It also needs to be resident. An agent window sits open all day beside your editor, so idle memory and startup time are not benchmarks, they are the daily experience.
| Measure | Tauri | Electron | Flutter desktop |
|---|---|---|---|
| Installer size | 3.8MB | ~165MB | ~18MB |
| Idle memory | 25 to 40MB | 90 to 180MB | 45 to 70MB |
| Rendering engine | System webview | Bundled Chromium | Bundled engine |
| Back end language | Rust | Node.js | Dart |
Published comparison figures. The gap on installer size is roughly 43x, which matters for direct downloads.
Image goes here
/blog/why-quaka-tauri-architecture.png
Architecture diagram: React UI, Tauri IPC, Rust commands, SQLite
Show generation prompt
Editorial technical architecture diagram, 16:9, flat vector, stacked vertically in four layers: a browser window icon (React UI) at the top, a thin double-arrow bridge (IPC) below it, a row of gear icons (Rust commands) in the middle, and a database cylinder (SQLite) at the bottom. Thin labeled connector lines run downward through each layer. Charcoal (#121212) background, grey (#8c8c8c) outlines, the IPC bridge and gear row in indigo (#5560d4), ordered-dither dot texture in the background, generous negative space, centered composition. Mood: layered, architectural. No readable text, no logos, no watermark.
Why Rust specifically
Memory safety is the obvious answer, and it matters more here than in a typical app because the process is handling concurrent streams, timeouts and tool output buffers at the same time. Rust gets that without a garbage collector, so there is no pause in the middle of a streaming response.
The more practical reason is where the checks live. In a TypeScript-only agent, a mode constraint is a conditional in application code that a refactor can quietly bypass, or worse, a line in a prompt. In a Rust harness the allowlist is applied by the runtime before dispatch, and the same compiler that catches a missing case catches a permission check nobody wired up.
- Named commands instead of a general API. The front end can only call what has been declared, so the reachable surface is explicit.
- Filesystem and shell access are opt-in. Configuration declares what the app may touch, rather than the app having everything by default.
- Streaming SSE and JSON-RPC are handled natively. Cancellation, retries and aborts are ordinary Rust control flow rather than races in async JavaScript.
- No bundled browser. The system webview is already on every machine, which is where the 43x size difference comes from.
What the rest of the stack looks like
The front end is React 19 with Vite, Tailwind and shadcn/ui, using Inter for interface chrome and JetBrains Mono in the terminal. Threads, runs and settings live in SQLite with write-ahead logging, which is what makes resuming after a crash reliable rather than hopeful.
The embedded terminal is xterm with fit and link addons, so commands the agent runs are visible in the same window as the text around them. Provider calls stream over SSE from the Rust side, which keeps API keys out of the browser context entirely, and any OpenAI-compatible endpoint can be configured without the front end knowing the difference.
That last point is the architectural argument in miniature: the front end asks a named command for something, the back end decides whether it is allowed and executes it, and the interface never learns where the API key is. For how that discipline shows up in the run itself, the harness post walks through the five jobs the harness owns.
Get an invite
Quaka is in private beta.
One email when your invite is ready. macOS, Windows and Linux, bring your own key.
Read the source on GitHubCommon questions
Why not build a coding agent with Electron?
You can, and several good ones are. The costs are footprint and where your permission checks live: roughly 165MB install and 90 to 180MB idle memory against under 4MB and 25 to 40MB, and a back end where constraints are application logic rather than enforced by the runtime. For a small utility the difference does not matter; for a resident agent that runs your shell, it does.
Is Tauri stable enough for production desktop apps?
Tauri v2 is in production use with mobile support and a maturing plugin ecosystem. The main considerations are the younger ecosystem relative to Electron and minor rendering differences between operating system webviews, both of which are acceptable when you are building an interface rather than a canvas-heavy application.
Does using Rust make the coding agent itself smarter?
No, the model does the thinking. What Rust changes is everything around it: timeouts that actually fire, streaming without garbage collection pauses, tool dispatch that cannot skip a permission check, and a test suite over the scheduling and trajectory logic. It is harness quality, which is where most agent differences come from.