streamerOS

Most streaming toolkits are heavy. Overlay suites, chat bots, and alert services each spawn their own browser engine, idle at double-digit CPU, and round-trip your audience's chat through someone else's cloud — adding latency and quietly exporting data you never agreed to share. On a machine that is already encoding video, that overhead is the difference between a smooth broadcast and dropped frames.

streamerOS is a native desktop cockpit that collapses telemetry, multi-platform chat, and scene automation into a single Rust binary. It runs everything locally and stays out of the way — a ~152 MB resident / 1.8% idle CPU footprint — so the GPU and encoder keep the headroom that matters.

Who it's for: Twitch and YouTube streamers who run on the same PC they game on, value privacy, and want OBS to react to chat automatically without a fragile stack of plugins and cloud webhooks.

The 1.8% CPU / 152 MB RAM footprint

The budget is held by architecture, not micro-tuning. There is no embedded browser — Tauri renders the UI in the OS WebView, which alone saves the ~150 MB an Electron app spends before it does any work. The core is event-driven: nothing polls. Sockets wake tasks only when bytes arrive, so idle cost approaches zero.

Chat parsing is zero-copy — messages are sliced out of the receive buffer rather than allocated per line — and producers feed consumers through bounded channels, so a chat flood applies backpressure instead of ballooning memory.

// Bounded queue: chat floods apply backpressure, not unbounded growth.
let (tx, mut rx) = tokio::sync::mpsc::channel::<ChatEvent>(1024);

tokio::spawn(async move {
    while let Some(ev) = rx.recv().await {
        // score velocity/sentiment without leaving the worker thread
        analyzer.ingest(&ev);
    }
});

Real-time local Twitch / YouTube chat ingestion

Each platform connects directly from the user's machine. The Twitch IRC client runs a reconnect state machine with exponential backoff and jitter; YouTube Live chat is consumed on its own task. Both normalize into one ordered, de-duplicated event stream. Crucially, chat never leaves the device for a third-party relay — the only network peers are Twitch, YouTube, and your local OBS. That is the zero-leakage guarantee.

OBS WebSocket v5 scene routing

streamerOS speaks OBS WebSocket v5 over a single multiplexed connection: it subscribes to the event stream, batches outbound requests, and maps automation rules to scene switches and source toggles. A debounced, priority-resolved dispatcher prevents a burst of triggers from thrashing scenes.

// Webview side: receive batched, MessagePack-decoded events from Rust core.
listen<ChatBatch>("chat:batch", ({ payload }) => {
  meters.apply(payload.velocity);      // 60fps, transform-only
  if (payload.hype > THRESHOLD) {
    invoke("obs_set_scene", { scene: "HYPE" }); // -> OBS WebSocket v5
  }
});