rvoip

A unified Rust substrate for real-time voice — SIP today, WebRTC + QUIC + AI agents next.

📚 Docs · 🚀 Quick start · 🎯 Build with rvoip · 📊 Feature support · 🏗️ Architecture · 🗺️ Roadmap · 💡 Why rvoip

[!NOTE] Release status. Maturity is encoded in the version number (no -alpha/-beta suffixes): 0.1.x = alpha, 0.2.x = beta, 1.0 = stable. The SIP product (rvoip-sip + its spine) is a beta candidate at 0.2.2 for bounded SIP client, server, PBX, gateway, and B2BUA scenarios. The rest of the workspace — WebRTC, QUIC, WebTransport, WebSocket, UCTP, vCon, identity, AI harness — is alpha, published at 0.1.0 (API-unstable; expect breaking changes before 1.0). The rvoip 3 vision describes the destination.

⚡ rvoip in one breath

After the SIP era (VoIP 1.0) and the web-meets-voice era of WebRTC + VoiceXML (VoIP 2.0), rvoip is the third generation: SIP, WebRTC, QUIC, and AI-agent participants share a single transport-agnostic conversation model. One Rust library hosts all of them. Cross-substrate bridging — SIP ↔ WebRTC ↔ QUIC — is a first-class primitive, not glue code.

The full design lives under docs/:

🎯 Build with rvoip today

What you can ship right now on the beta:

Pick the lowest-ceremony API that gives you what you need. All four sit on the same UnifiedCoordinator underneath; you can drop down a layer without switching stacks.

🚀 Quick start

[dependencies]
rvoip-sip = "0.2.2"
tokio = { version = "1", features = ["full"] }

A complete two-endpoint local call. Bob waits, Alice dials, they hold the line for a second, then hang up.

use std::time::Duration;
use rvoip_sip::{Config, Endpoint, EndpointProfile};

#[tokio::main]
async fn main() -> rvoip_sip::Result<()> {
    // bob waits for an incoming call
    let bob = tokio::spawn(async {
        let mut bob = Endpoint::builder()
            .name("bob")
            .profile(EndpointProfile::Custom(Config::local("bob", 5071)))
            .build()
            .await?;
        let incoming = bob.wait_for_incoming().await?;
        let call = incoming.answer().await?;
        call.wait_for_end(None).await?;
        bob.shutdown().await
    });

    tokio::time::sleep(Duration::from_millis(300)).await;

    // alice dials bob
    let alice = Endpoint::builder()
        .name("alice")
        .profile(EndpointProfile::Custom(Config::local("alice", 5070)))
        .build()
        .await?;

    let call = alice
        .call_and_wait("sip:bob@127.0.0.1:5071", Some(Duration::from_secs(10)))
        .await?;
    tokio::time::sleep(Duration::from_secs(1)).await;
    call.hangup_and_wait(Some(Duration::from_secs(5))).await?;
    alice.shutdown().await?;
    bob.await.unwrap()
}

Try it:

cargo run -p rvoip-sip --example endpoint_local_call

New here? Start with the scenario examples in examples/ — a guided, well-documented path from a first P2P call through audio, registration, call control, transfers, SRTP/TLS, an IVR server, and a B2BUA call center, each a standalone project with a ./run_demo.sh.

For per-API-surface reference examples (one lane each for endpoint, stream_peer, callback_peer, unified, plus protocol regression fixtures and PBX interop), see crates/sip/rvoip-sip/examples/.

📊 Feature support

✅ Beta (0.2.2) = RFC-correct, tested · 🚧 Alpha (0.1.0) = published, API-unstable · 🔮 Roadmap = planned, not yet implemented

📞 SIP methods (RFC 3261 + extensions)

🎵 Media plane

🌐 Transport

🔐 Security & identity

🚀 Performance claim

The crates/sip/rvoip-sip/docs/RFC_COMPLIANCE_MATRIX.md and crates/sip/rvoip-sip/docs/SECURITY_POSTURE.md documents are the authoritative source — this table is a summary.

🏗️ Architecture

┌──────────────────────────────────────────────────────────────┐
│  📱 Application                                              │
│  (softphone, PBX, contact center, voice AI agent, ...)       │
└──────────────────────────────────────────────────────────────┘
                              ▲
                              │ rvoip-sip API surface
                              ▼
┌──────────────────────────────────────────────────────────────┐
│  📞 rvoip-sip       (✅ beta)  SIP-shaped session layer       │
│  ┌─────────────┬───────────────┬─────────────┬─────────────┐ │
│  │ sip-core    │ sip-transport │ sip-dialog  │ sip-proxy   │ │
│  │             │               │             │ sip-registrar│ │
│  └─────────────┴───────────────┴─────────────┴─────────────┘ │
└──────────────────────────────────────────────────────────────┘
                              ▲
                              │ ConnectionAdapter trait
                              ▼
┌──────────────────────────────────────────────────────────────┐
│  🧬 rvoip-core      (✅ beta)  transport-agnostic spine       │
│  rvoip-core-traits  (✅ beta)  cycle-breaker trait surface    │
│  rvoip-media-core   (✅ beta)  codec / mixing / MediaStream   │
│  rvoip-rtp-core     (✅ beta)  RTP / SRTP                     │
│  rvoip-codec-core   (✅ beta)  G.711 + optional G.729A/AB      │
│  rvoip-auth-core    (✅ beta)  OAuth2 / Bearer / SIP Digest   │
└──────────────────────────────────────────────────────────────┘
                              ▲
                              │ UCTP (🚧 alpha)
                              ▼
┌──────────────────────────────────────────────────────────────┐
│  🚧 Substrate adapters  (alpha — not in beta closure)         │
│  ┌─────────┬──────────┬───────────────┬───────────────┐      │
│  │ rvoip-  │ rvoip-   │ rvoip-        │ rvoip-        │      │
│  │  webrtc │  quic    │  webtransport │  websocket    │      │
│  └─────────┴──────────┴───────────────┴───────────────┘      │
│  rvoip-uctp · rvoip-vcon · rvoip-harness · rvoip-identity    │
└──────────────────────────────────────────────────────────────┘

The dependency direction is enforced. rvoip-core never imports an adapter crate. Adapters depend on rvoip-core and register themselves via ConnectionAdapter. This is what lets a single Orchestrator bridge a SIP call to a WebRTC client (and, later, to a QUIC peer or an AI participant) without the substrates knowing about each other.

📦 Crate matrix

✅ Beta — published to crates.io as 0.2.2

🚧 Alpha — published to crates.io at 0.1.0

These publish at 0.1.0 (API-unstable) so the rvoip facade can expose them behind feature flags (webrtc, uctp, voip-3, sip-stir-shaken, client). Expect breaking changes before each graduates to beta.