platform

Neutron Desktop

Tauri 2.0 with Neutron Rust underneath. System WebView for UI, embedded Nucleus for data, 12 typed plugins for OS integration. ~10 MB bundles, Rust safety, no Chromium.

Desktop apps that don't ship a browser.

Available

~10 MBTypical Bundle

12Typed Plugins

Tauri 2.0Runtime

EmbeddedNucleus

Electron wrote a browser into your install. Don't.

Electron ships a 120 MB Chromium bundle, idles at 200 MB of RAM, and runs your backend on Node. Neutron Desktop uses Tauri 2.0 with your system's native WebView, a Rust backend on the same Neutron framework you'd use for the web, and an embedded Nucleus instance so your app has a real database without requiring one to be running.

src-tauri/src/main.rs
use neutron_desktop::{App, Nucleus};
use neutron::prelude::*;

#[tauri::command]
async fn search(q: String, db: State<'_, NucleusClient>) -> Result<Vec<Hit>, String> {
    let hits = db.vector()
        .search("docs", &embed(&q))
        .k(10)
        .execute()
        .await
        .map_err(|e| e.to_string())?;
    Ok(hits)
}

fn main() {
    App::builder()
        .embedded_nucleus()
        .plugin(neutron_desktop::tray())
        .plugin(neutron_desktop::hotkey())
        .plugin(neutron_desktop::autostart())
        .invoke_handler(tauri::generate_handler![search])
        .run(tauri::generate_context!())
        .expect("failed to start");
}
Rust backend + Nucleus embedded + typed neutron:// bridge.

System WebView

WebKit on macOS, WebView2 on Windows, WebKitGTK on Linux. Already installed, already updated, already patched.

Rust backend

The Neutron Rust framework powers the desktop backend. Memory-safe, no GC pauses, one binary.

Embedded Nucleus

Ship your app with Nucleus linked in. All 14 data models, persistent across restarts, zero network hops, no server to install.

12 typed plugins

Clipboard, shell, tray, hotkeys, autostart, window-state, deep-link, biometrics, updater, notifications, file-system, store.

neutron:// bridge

Custom protocol handler for safe file access and IPC. Typed commands from the WebView, zero-copy where possible.

Auto-updates

Signed deltas delivered from your server, applied without a reinstall. Rollback support on failure.

Metric	Electron	Neutron Desktop
Typical bundle	~120 MB	~10 MB
Memory (idle)	~200 MB	~30–50 MB
Backend	Node.js	Rust (same Neutron framework)
Browser engine	Bundled Chromium	System WebView
Security posture	Node.js CVEs	Rust memory safety
Database	BYO	Nucleus embedded, 14 models

Why Tauri 2.0

Bundle

~10× smaller than Electron

Memory

4–6× less at idle

Backend

Rust, memory-safe, no GC pauses

Updates

System WebView patches itself

IPC

Typed commands, zero-copy

What it's for

Developer tools (Nucleus Studio itself is built on this stack). Productivity apps where binary size matters. Offline-first apps where the user owns the data. Internal tools that must run on airgapped networks. Anywhere you'd reach for Electron but the 120 MB install gives you pause.

Why embed Nucleus?

Because a desktop app with a real database beats a file-format war. You get SQL, vector search, full-text, and time-series out of the box, persisting across restarts without a daemon. When users need to sync, replicate to a Nucleus cluster; when they don't, it's just a file on disk.

Part of a bigger system

The same Preact components render to web, iOS, Android, and desktop. The same Rust backend compiles to a server, a desktop app, or a Tauri sidecar. Your users get native-feeling apps; your code stays one codebase.