#Rust
18 articles — newest first.
- 7 min read
Tauri + sqlx + SQLite: migrations and WAL for local apps
Practical guide to embedding SQLite in Tauri with sqlx: file location, compile-time migrations, WAL pragmas, and failure modes for single-user datastores.
- 8 min read
On-Device Twitch IRC in Rust: Reconnect State Machine + Backoff
Build a fully local Twitch chat ingestor in Rust with a resilient WebSocket reconnect loop, exponential backoff with jitter, and a pragmatic state machine that survives flaky networks.
- 7 min read
Kill Async Deadlocks in Tauri with Tokio Task Dumps + Tracing
A field guide to diagnosing and terminating async deadlocks in production Tauri apps using Tokio task dumps, tokio-console, and end-to-end tracing spans.
- 8 min read
Zero-copy scene caches with memmap2: instant loads, no RSS bloat
Use memory-mapped files to load massive scene assets instantly and safely without duplicating data in heap and page cache. Concrete Rust patterns inside.
- 8 min read
Flamegraphs over Tauri IPC: from Rust event to React paint
A practical, end-to-end method to profile Tauri apps: correlate Rust spans with React paints, align clocks, and read a single cross-IPC flamegraph.
- 8 min read
SIMD sentiment scoring in Rust via WASM workers (no UI jank)
Build a SIMD-accelerated sentiment scorer in Rust, ship it as WebAssembly, and keep chat analysis off the UI thread without hurting battery or FPS.
- 7 min read
Everyone Said 'Just Use Electron.' I Wrote streamerOS in Rust — Here's What That Bought
streamerOS runs on the most contested consumer PC there is — game, encoder, OBS, chat. Why a Rust + Tauri core, on-device chat ingestion, and a MessagePack IPC bridge were the product decision, not a preference.
- 7 min read
Shrink streamerOS Rust binaries: opt=z, fat LTO, panic=abort
A practical, measured look at how opt-level=z, fat LTO, and panic=abort shrink Rust binaries for production systems like streamerOS—and the trade-offs.
- 7 min read
Rust structured concurrency: cap media decoders w/ tokio JoinSet
Use tokio JoinSet and semaphores to bound parallel media decoders, enforce backpressure, and build cancellation-safe ffmpeg workers with structured concurrency.
- 9 min read
Pinning a 1.8% Idle CPU: Evented vs Polling in Tauri Tray Apps
A ruthless, code-first look at hitting a ~1.8% idle CPU budget in long‑running Tauri tray apps by replacing polling with event‑driven plumbing.
- 7 min read
Crossbeam SPSC ring buffers for 60 FPS Rust audio meters
Build a zero-allocation, lock-free SPSC ring buffer with crossbeam to stream audio metering data to a 60 FPS UI in Rust without contention.
- 7 min read
A reproducible RAM-regression workflow in Rust with dhat + heaptrack
A practical, deterministic workflow to catch and bisect memory regressions in a Rust media pipeline using dhat for budgets and heaptrack for call stacks.
- 8 min read
Halving Tauri v2 IPC: Batch Events + rmp-serde MessagePack
Cut Tauri v2 Rust↔WebView IPC overhead by batching events and serializing with rmp-serde MessagePack, with concrete code for both sides.
- 6 min read
serde_json to simd-json in streamerOS IPC: hot-path deserialization
We replaced serde_json with simd-json in streamerOS’s IPC layer and benchmarked the deserialize hot path, showing where SIMD wins and where it doesn’t.
- 7 min read
Tauri Rust Backpressure: Bounded vs Unbounded Channels for Chat Floods
Design a Tauri Rust core that survives chat floods without memory blowups using bounded channels, drop-oldest semantics, and time-based batching.
- 7 min read
Zero-copy Twitch IRC parsing in Rust with Bytes + nom at 5k/s
Build a zero-copy Twitch IRC parser in Rust using bytes::Bytes and nom to sustain 5,000+ messages/sec without heap churn or unnecessary allocations.
- 8 min read
Rust arena allocation to keep streamerOS under 152 MB for 12h
Practical, code-first arena allocation patterns in Rust that kept our live-streaming OS under 152 MB RAM for 12-hour broadcasts with zero leaks.
- 8 min read
Tauri v2 + tokio-console: 1.8% CPU with 4 concurrent streams
A field-tested workflow to profile and tune a Tauri v2 Rust backend using tokio-console, slashing wake storms and sustaining 1.8% CPU across 4 streams.