# Pluto RTC Rust Core
The Rust crate is the realtime engine behind Pluto RTC.
It powers:
- the native runtime used by Tauri and other native hosts
- the WASM runtime loaded by the npm package in browsers
## Core Responsibilities
- app-scoped device discovery
- presence publishing and cleanup
- signaling messages and sessions
- room membership
- peer identity resolution
- iroh endpoint lifecycle and connection management
- shared runtime records used by both native and WASM hosts
## Native vs WASM
### Native
Used for:
- Tauri desktop/mobile-style hosts
- headless or CLI-style runners
- advanced endpoint and router integration
Native-only features include:
- endpoint adoption/export
- custom router / no-internal-router mode
- native auth relay helpers
- protocol registry and plugin registration
### WASM
The same runtime logic compiles to WebAssembly for browser hosts.
The npm package loads that WASM build and forwards auth/runtime configuration into it. The browser path should behave like the native path at the runtime-contract level.
## Recommended Native Shape
- use `ClientBuilder` / injected runtime construction
- keep host-specific behavior outside the core where possible
- use the runtime manager and protocol registry for advanced native composition
## Peer Sessions and Custom Protocols
The Rust core owns one peer-session view per `deviceId`. Host layers should
consume connected peer-session snapshots rather than reason about transport
records directly.
Protocol authors have two supported extension paths:
1. **Session-adjacent stream composition**
- wait for a connected peer session
- open `open_bi` / `open_uni` streams
- define framing and message semantics externally
2. **ALPN protocol plugins**
- register protocol plugins through `RuntimeManager` / `ProtocolRegistry`
- use `SessionAdjacent` plugins for runtime-ready hooks without ALPN routing
- use `Alpn` plugins when the native runtime should register a dedicated ALPN
WASM/browser consumers should prefer the first model. The second is a
Rust-first advanced capability.
## Important Rule
Rust owns discovery, signaling, presence, lifecycle, and peer identity. TypeScript should wrap those contracts, not duplicate them.