videocall.rs

An open-source, ultra-low-latency video conferencing platform and API built with Rust. Designed for software professionals, robotics, and embedded systems, it supports WebTransport with WebSocket fallback for high-performance real-time communication.

Website | Discord Community

⚡ Quick Links

• Documentation - Comprehensive guides and API reference.
• Crates.io - Download the CLI tool.
• Report a Bug - Help us improve.

🌟 Star History

Who is this for?

• Software Professionals: Build custom video applications with a modern, type-safe Rust API.
• Robotics & IoT Engineers: Stream ultra-low-latency video from drones, robots, and embedded devices (Raspberry Pi, Jetson Nano) using our lightweight CLI and SDKs.
• Privacy Advocates: Self-host your own video conferencing infrastructure with secure JWT authentication and SSO support.

Table of Contents

• Overview
• Features
• Compatibility
• Why WebTransport Instead of WebRTC?
• System Architecture
• Getting Started
  • Prerequisites
  • Docker Setup
  • Nix Build System (WIP)
  • Manual Setup
• Runtime Configuration
  • Local (no Docker)
  • Local/Docker
  • Kubernetes/Helm
• Usage
• Meeting Management
• Performance
• Security
• Feature Flags
• Testing
  • UI Testing (yew-ui)
  • Backend Testing (actix-api)
• Roadmap
• Contributing
• Project Structure
• Demos and Media
• Contributors
• License

Overview

videocall.rs is a modern, open-source video conferencing system written entirely in Rust. It is designed for software professionals and robotics engineers who need reliable, scalable, and secure real-time communication capabilities. It provides a robust foundation for building custom video communication solutions, from web apps to autonomous vehicle feeds, with support for both browser-based and native clients.

Project Status: Beta - Actively developed and suitable for non-critical production use

Features

• Ultra-Low Latency: Built with Rust for sub-100ms latency, ideal for robotics and real-time control.
• Multiple Transport Protocols: WebTransport with automatic WebSocket fallback for maximum compatibility.
• Secure Authentication: JWT-based access control with SSO/OAuth support.
• Scalable Architecture: Designed with a pub/sub model using NATS for horizontal scaling (Mesh/SFU hybrid).
• Cross-Platform Support: Chromium-based browsers and Safari supported.
• Robotics & Embedded: High-performance CLI and SDK for headless streaming from Raspberry Pi, Jetson Nano, and other embedded Linux devices.
• Open Source: MIT licensed for maximum flexibility.

Compatibility

Why WebTransport Instead of WebRTC?

WebTransport is a core technology that differentiates videocall.rs from traditional video conferencing solutions. As a developer, here's why our WebTransport approach is technically superior:

Technical Advantages

• No SFUs, No NAT Traversal: WebTransport eliminates the need for complex Selective Forwarding Units and NAT traversal mechanisms that plague WebRTC implementations and cause countless developer headaches.

• Simplified Architecture: No more complex STUN/TURN servers, ICE candidates negotiation, or complicated signaling dances required by WebRTC. Just direct, straightforward connections.

• Protocol Efficiency: Built on HTTP/3 and QUIC, WebTransport provides multiplexed, bidirectional streams with better congestion control and packet loss recovery than WebRTC's dated SCTP data channels.

• Lower Latency: QUIC's 0-RTT connection establishment reduces initial connection times compared to WebRTC's multiple roundtrips.

• Clean Development Experience: WebTransport offers a more intuitive developer API with a promise-based design and cleaner stream management.

• Future-Proof: As part of the modern web platform developed by the IETF and W3C, WebTransport has strong browser vendor support and an actively evolving specification.

Developer Implications

For developers integrating videocall.rs, this means:

• ✅ Drastically simpler deployment architecture
• ✅ No complex network configuration or firewall issues
• ✅ Better performance in challenging network conditions
• ✅ More predictable behavior across implementations
• ✅ Less time spent debugging connectivity issues
• ✅ A forward-looking technology investment

Read our Architecture Document for a deep dive into how we implement WebTransport and the technical benefits it provides.

System Architecture

videocall.rs follows a microservices architecture with these primary components:

graph TD
    Clients[Clients<br>Browsers, Mobile, CLI] -->|WebSocket| ActixAPI[Actix API<br>WebSocket]
    Clients -->|WebTransport| WebTransportServer[WebTransport<br>Server]
    ActixAPI --> NATS[NATS<br>Messaging]
    WebTransportServer --> NATS

1. actix-api: Rust-based backend server using Actix Web framework
2. yew-ui: Web frontend built with the Yew framework and compiled to WebAssembly
3. videocall-types: Shared data types and protocol definitions
4. videocall-client: Client library for native integration
5. videocall-cli: Command-line interface for headless video streaming

For a more detailed explanation of the system architecture, please see our Architecture Document.

Getting Started

⭐ RECOMMENDED: Docker is the only fully supported development method ⭐

We strongly recommend using the Docker-based setup for development, as it's well-maintained and provides consistent behavior across platforms. The manual setup described below is not as well maintained and may require additional troubleshooting.

Prerequisites

• Modern Linux distribution, macOS, or Windows 10/11
• Docker and Docker Compose (for containerized setup)
• Rust toolchain 1.89+ (for manual setup)
• Chromium-based browser (Chrome, Edge, Brave) for frontend access - Firefox is not supported
• Safari both in iOS and macOS are supported for frontend access

Docker Setup

The quickest way to get started is with our Docker-based setup:

1. Clone the repository:

   git clone https://github.com/security-union/videocall-rs.git
   cd videocall-rs
   

2. Start the server (replace <server-ip> with your machine's IP address):

   make up
   

3. Open Chrome using the provided script for local WebTransport:

   ./launch_chrome.sh
   

4. Access the application at:

   http://<server-ip>/meeting/<username>/<meeting-id>
   

Nix Build System (WIP)

We are migrating the build infrastructure to Nix for reproducible, fast builds. Currently the leptos-website is the first component being nixified.

Status: Work in progress — see the nixify-docker-build branch.

What Nix replaces: Previously, Docker builds spent 15-20 minutes compiling tools like cargo-leptos and wasm-bindgen-cli from source on every build. Nix provides these as pre-built binaries from the binary cache, reducing tool setup from minutes to seconds.

What's done so far:

• flake.nix at the repo root provides dev shells with pinned versions of the Rust nightly toolchain, cargo-leptos, wasm-bindgen-cli, binaryen, Node.js, and system dependencies
• docker/Dockerfile.website and docker/Dockerfile.website.dev use nixos/nix as a builder image
• .github/workflows/leptos-website-build.yaml uses DeterminateSystems/nix-installer-action with magic-nix-cache-action for cached CI builds

Quick start (requires Nix):

The integration is transparent to the user, and the development experience is the same as with Docker.

What's next: Nixifying additional components (actix-api, yew-ui) and evaluating crane for full Nix-managed Rust dependency caching.

Manual Setup (Experimental)

⚠️ Warning: This setup method is experimental and not as well maintained as the Docker approach. You may encounter issues that require manual debugging.

For advanced users who prefer to run services directly on their machine:

1. Create a PostgreSQL database:

   createdb actix-api-db
   

2. Install required tools:

   # Install NATS server
   curl -L https://github.com/nats-io/nats-server/releases/download/v2.9.8/nats-server-v2.9.8-linux-amd64.tar.gz | tar xz
   sudo mv nats-server-v2.9.8-linux-amd64/nats-server /usr/local/bin
   
   # Install trurl
   cargo install trurl
   

3. Start the development environment:

   ./start_dev.sh
   

4. Connect to:

   http://localhost:8081/meeting/<meeting-id>
   

For detailed configuration options, see our setup documentation.

Runtime Configuration (Frontend config.js)

The Yew UI is configured at runtime via a window.__APP_CONFIG object provided by a config.js file. The file is copied by Trunk and loaded at /config.js by yew-ui/index.html.

Local (no Docker): create yew-ui/scripts/config.js

• Start services with ./start_dev.sh.
• Create yew-ui/scripts/config.js that assigns window.__APP_CONFIG = Object.freeze({...}).
• Keep the keys in sync with the authoritative sources below. Trunk will copy the file and the app will pick it up on refresh.
• Tip: mkdir -p yew-ui/scripts to ensure the directory exists.

Authoritative keys and defaults: see docker/start-yew.sh and the Helm template referenced below.

Local/Docker: start-yew.sh

docker/start-yew.sh generates /app/yew-ui/scripts/config.js from environment variables at container startup. For the current list of supported variables and defaults, refer directly to docker/start-yew.sh. Restart the container to apply changes.

Kubernetes/Helm: configmap-configjs.yaml

helm/rustlemania-ui/templates/configmap-configjs.yaml renders config.js from .Values.runtimeConfig. Define runtimeConfig in your values file and deploy/upgrade. For the exact structure and latest behavior, refer to the template itself.

Usage

Browser-Based Clients

1. Navigate to your deployed instance or localhost setup:

   http://<server-address>/meeting/<username>/<meeting-id>
   

2. Grant camera and microphone permissions when prompted

3. Click "Connect" to join the meeting

CLI-Based Streaming

For headless devices like Raspberry Pi:

# Install the CLI tool
cargo install videocall-cli

# Stream from a camera
videocall-cli stream \
  --user-id <your-user-id> \
  --video-device-index 0 \
  --meeting-id <meeting-id> \
  --resolution 1280x720 \
  --fps 30 \
  --frame-format NV12 \
  --bitrate-kbps 500

For detailed information about the CLI tool and all available options, see the videocall-cli README.

Meeting Management

videocall.rs includes a comprehensive meeting management system with ownership, waiting rooms, and host controls.

Key Features

• Meeting Ownership: Each meeting has an owner (the creator) identified by their email
• My Meetings: Users can view and manage all meetings they own from the home page
• Waiting Room: Non-owners enter a waiting room and must be admitted by an existing participant
• Host Identification: The meeting owner is visually identified with "(Host)" in the UI
• Soft Delete: Owners can delete their meetings; deleted meeting IDs can be reused

Meeting Workflow

1. Create/Join: Navigate to /meeting/{meeting-id} - if the meeting doesn't exist, you become the owner
2. Start/Join Button: Owners see "Start Meeting", others see "Join Meeting"
3. Waiting Room: Non-owners wait for admission; admitted participants can manage the waiting room
4. Auto-Join: When admitted from the waiting room, participants automatically enter the meeting

Documentation

For detailed information about the meeting system:

• Meeting Ownership & Workflow - Ownership model, lifecycle, and user workflows
• Meeting API Reference - Complete API endpoint documentation

Enabling Meeting Management

Meeting management requires the FEATURE_MEETING_MANAGEMENT flag:

export FEATURE_MEETING_MANAGEMENT=true

Or in Docker:

docker run -e FEATURE_MEETING_MANAGEMENT=true ...

Performance

videocall.rs has been benchmarked and optimized for the following scenarios:

• 1-on-1 Calls: Minimal resource utilization with <100ms latency on typical connections
• Small Groups (3-10): Efficient mesh topology with adaptive quality based on network conditions
• Large Conferences: Tested with up to 1000 participants using selective forwarding architecture

Technical Optimizations

• Zero-Copy Design: Minimizes data copying between network stack and application code
• Asynchronous Core: Built on Rust's async/await ecosystem with Tokio runtime
• SIMD-Accelerated Processing: Uses CPU vectorization for media operations where available
• Lock-Free Data Structures: Minimizes contention in high-throughput scenarios
• Protocol-Level Optimizations: Custom-tuned congestion control and packet scheduling

Resource Utilization

Our server-side architecture is designed for efficiency at scale:

• Horizontal Scaling: Linear performance scaling with additional server instances
• Load Distribution: Automatic connection balancing across server pool
• Resource Governance: Configurable limits for bandwidth, connections, and CPU utilization
• Container-Optimized: Designed for efficient deployment in Kubernetes environments

Performance metrics and tuning guidelines will be available in our performance documentation. (WIP)

Security

Security is a core focus of videocall.rs:

• Transport Security: All communications use TLS/HTTPS.
• Authentication: Flexible integration with identity providers (SSO/OAuth).
• Access Controls: Fine-grained permission system for meeting rooms.

For details on our security model and best practices, see our security documentation.

Feature Flags

videocall.rs uses environment-based feature flags to enable or disable experimental or optional functionality at runtime. Flags are loaded lazily on first access and can be overridden for testing purposes.

Configuration

Feature flags are set via environment variables with the FEATURE_ prefix:

# Enable a feature flag
export FEATURE_MEETING_MANAGEMENT=true

# Or when running with Docker
docker run -e FEATURE_MEETING_MANAGEMENT=true ...

Available Flags

Truthy Values

The following values are recognized as enabling a flag (case-insensitive):

• true
• 1
• yes

Any other value (or unset variable) is treated as false.

Testing

UI Testing (yew-ui)

The Yew frontend uses a three-layer testing pyramid, all running in a real browser via wasm-bindgen-test:

# Run UI component tests natively (requires Chrome + chromedriver)
make yew-tests

# Run in headed mode to watch the browser
make yew-tests HEADED=1

# Run UI component tests in Docker (no local deps needed)
make yew-tests-docker

CI runs these tests automatically via .github/workflows/wasm-test.yaml. For the full testing guide — including how to write new tests, the test harness API, and the mock device vs real fake device strategy — see yew-ui/TESTING.md.

Backend Testing (actix-api)

The actix-api crate contains unit and integration tests that run against real PostgreSQL and NATS instances, spun up via Docker Compose. Tests cover:

• Session management — meeting creation, multi-user join/leave, host controls, system email rejection
• WebSocket transport — full meeting lifecycle over WebSocket connections
• WebTransport — meeting lifecycle over QUIC/HTTP3
• Packet handling — classification of empty, garbage, and RTT packets
• Metrics server — session tracking, health metrics export, stale session cleanup, concurrent access
• Feature flags — behavior with FEATURE_MEETING_MANAGEMENT on and off

Tests use #[serial_test::serial] because they share a database, and each test cleans up its own data. The infrastructure is defined in docker/docker-compose.integration.yaml, which provides:

# Build + run all backend tests (PostgreSQL + NATS in Docker)
make tests_run

# Tear down test containers
make tests_down

CI runs these tests automatically via .github/workflows/cargo-test.yaml, triggered on PRs that touch actix-api/, videocall-types/, or protobuf/. For the full backend testing guide — including test patterns, database cleanup, and how to write new tests — see actix-api/TESTING.md.

Roadmap

Contributing

We welcome contributions from the community! Here's how to get involved:

1. Issues: Report bugs or suggest features via GitHub Issues

2. Pull Requests: Submit PRs for bug fixes or enhancements

3. RFC Process: For significant changes, participate in our RFC process

4. Community: Join our Discord server to discuss development

See our Contributing Guidelines for more detailed information.

Technology Stack

• Backend: Rust + Actix Web + PostgreSQL + NATS
• Frontend: Rust + Yew + WebAssembly + Tailwind CSS
• Transport: WebTransport (QUIC/HTTP3) + WebSockets (fallback)
• Build System: Cargo + Trunk + Nix (WIP) + Docker + Helm
• Testing: cargo test + wasm-bindgen-test (browser-based UI tests) + Docker Compose (backend integration)

Key Technical Features

• Bidirectional Streaming: Fully asynchronous message passing using QUIC streams
• Error Handling: Comprehensive Result-based error propagation throughout the codebase
• Modularity: Clean separation of concerns with well-defined interfaces between components
• Type Safety: Extensive use of Rust's type system to prevent runtime errors
• Binary Protocol: Efficient Protocol Buffer serialization for all messages

For a more comprehensive technical overview, see the Architecture Document.

Git Hooks

This repository includes Git hooks to ensure code quality:

1. Pre-commit Hook: Automatically runs cargo fmt before each commit to ensure consistent code formatting.
2. Post-commit Hook: Runs cargo clippy after each commit to check for potential code improvements.

To install these hooks, run the following commands from the project root:

# Create the hooks directory if it doesn't exist
mkdir -p .git/hooks

# Create the pre-commit hook
cat > .git/hooks/pre-commit << 'EOF'
#!/bin/sh

# Run cargo fmt and check if there are changes
echo "Running cargo fmt..."
cargo fmt --all -- --check

# Check the exit code of cargo fmt
if [ $? -ne 0 ]; then
    echo "cargo fmt found formatting issues. Please fix them before committing."
    exit 1
fi

exit 0
EOF

# Create the post-commit hook
cat > .git/hooks/post-commit << 'EOF'
#!/bin/sh

# Run cargo clippy after the commit
echo "Running cargo clippy..."
ACTIX_UI_BACKEND_URL="" WEBTRANSPORT_HOST="" LOGIN_URL="" WEBTRANSPORT_URL="" ACTIX_API_URL="" cargo clippy -- -D warnings

# Check the exit code of cargo clippy
if [ $? -ne 0 ]; then
    echo "Cargo clippy found issues in your code. Please fix them."
    # We can't abort the commit since it's already done, but we can inform the user
    echo "The commit was successful, but please consider fixing the clippy issues before pushing."
fi

exit 0
EOF

# Make the hooks executable
chmod +x .git/hooks/pre-commit .git/hooks/post-commit

These hooks help maintain code quality by ensuring proper formatting and checking for common issues.

Demos and Media

Technical Presentations

• Scaling to 1000 Users Per Call
• Initial Proof of Concept (2022)

Channels

• YouTube Channel

Contributors

Ready to Build?

Start your journey with videocall.rs today. Whether you're building a robot, a drone, or a next-gen video app, we have the tools you need.

Get Started with Docker or Download the CLI

License

This project is dual licensed under the MIT License and the Apache License 2.0. See the LICENSE-APACHE and LICENSE-MIT files for details.