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

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/:

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.

[dependencies]
rvoip-sip = "0.2.1"
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/.

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

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.

┌──────────────────────────────────────────────────────────────┐
│  📱 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 base codec               │
│  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.

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.

Tracked in detail under docs/GAP_PLAN.md. Highlights below.

• rvoip-websocket substrate adapter (graduate WS to ✅ beta)
• Full AAuth production status (waiting on IETF WG adoption)
• DTLS-SRTP fingerprint binding (feature-flagged, design in place)
• vCon Postgres reference store (rvoip-vcon-postgres)
• Inline envelope signature enforcement at adapter ingress

• SIP-over-QUIC adapter
• RTP-over-QUIC (RoQ)
• Media-over-QUIC (MoQ) for broadcast fan-out
• Multi-party SFU / MCU integration (LiveKit / mediasoup)
• AI agents as first-class peer Participants in multi-agent flows

Contact centers, CPaaS providers, and voice-AI platforms in 2025–2026 stitch together a polyglot stack: FreeSWITCH or Asterisk for SIP, Janus or mediasoup for WebRTC, RTPEngine for media bridging, and custom Lua / Python / Erlang for orchestration glue. rvoip targets the same workload as a single Rust process — SIP, WebRTC, and (eventually) UCTP substrates handled by one library, with bridging and transcoding as first-class primitives.

The Vapi / Retell / Bland / OpenAI-Realtime cohort proved real-time voice AI is a venture-scale market. rvoip is the first end-to-end Rust substrate aimed at that category — SIP B2BUA, AI harness with clean ASR/TTS/Dialog provider traits, WebRTC interop for browser users, and a single command/event surface for all of it.

For new builds that don't need the legacy footprint. Single Rust binary, async-first, memory-safe.

For carriers and ITSPs needing SIP trunking, PSTN interconnect, codec negotiation, STIR/SHAKEN passthrough, and billing-grade usage records without paying for orchestration features they don't need.

For the conversation-compliance market — rvoip-vcon is the first Rust implementation of the IETF vCon draft.

The UCTP substrate model gives rvoip a place to land SIP-over-QUIC, RoQ, and MoQ when those mature (2027–2029) without breaking the SIP path.

See docs/PRD.md §1.2 for the full positioning analysis.

# Get the source
git clone https://github.com/eisenzopf/rvoip.git
cd rvoip

# Build the workspace
cargo build --workspace

# Run a working example
cargo run -p rvoip-sip --example endpoint_local_call

# Run the SIP test suite
cargo test -p rvoip-sip -p rvoip-sip-core -p rvoip-sip-dialog \
            -p rvoip-sip-transport -p rvoip-sip-proxy -p rvoip-sip-registrar

Run the workspace test suite:

scripts/test_all.sh                  # workspace-wide test runner

Treat this release as a beta candidate. The beta scope is documented above — anything beyond it is the caller's responsibility to validate with their own interop, security, and performance gates.

• 🐛 Bugs: open an issue with reproduction steps
• 💡 Feature requests: discussions or issues — please reference the rvoip 3 docs for context
• 🔧 Pull requests welcome — workspace-wide tests run via scripts/test_all.sh

Licensed under the MIT license. See LICENSE.