Skip to content

README.md

Latest commit

 

History

History
278 lines (201 loc) · 10.2 KB

README.md

File metadata and controls

278 lines (201 loc) · 10.2 KB

NuGet Version NuGet Downloads GitHub Actions Workflow Status License badge

Livekit.Rtc.Dotnet

.NET SDK to integrate LiveKit's real-time video, audio, and data capabilities into your .NET applications using WebRTC. Access the same powerful API offered by client SDKs, but directly from your .NET server: connect to rooms as a participant, publish and subscribe to audio/video tracks, send and receive data messages, perform RPC calls, and more.

Note

This SDK does not provide Server APIs to manage LiveKit resources such as Rooms, Egress, Ingress or SIP. If you want to manage LiveKit APIs from your .NET backend, please check Livekit.Server.Sdk.Dotnet instead.

Design principles

This library is crafted based on three core principles:

  1. Livekit.Rtc.Dotnet uses the C# auto-generated protobuf implementation of LiveKit RTC protocol. This ensures compatibility and ease of maintenance as the API evolves.
  2. Livekit.Rtc.Dotnet uses C# FFI bindings to the LiveKit Rust SDK. This allows us to leverage existing, well-tested code for WebRTC functionality that is already in use in other LiveKit SDKs. It brings the benefits of native performance for any OS platform while providing a common .NET interface. The library includes precompiled native binaries for Windows, Linux, and macOS, for both x64 and ARM64 architectures.
  3. Livekit.Rtc.Dotnet maintains full feature parity with other LiveKit RTC SDKs for the server side, especially the two more mature ones: Node.js and Python.

Features

Real-Time Media

Publish and subscribe to audio/video tracks with full programmatic control. Process frames in real-time, mix audio sources, and build custom media pipelines. Perfect for server-side processing.

Data & Communication

Send reliable or lossy data messages, implement RPC request-response patterns, and build real-time chat with topic-based channels. Full control over data flow between participants.

Room & Participant Management

Active speaker detection, transcription support, connection quality monitoring, and 25+ event types for comprehensive room state management.

Security & Encryption

Built-in end-to-end encryption (E2EE) with AES-GCM, key rotation, and per-participant key management. Keep your sensitive communications secure, also in your .NET server.

Production-Ready

Automatic reconnection, multi-room support, isolated contexts, and battle-tested WebRTC implementation from the LiveKit Rust SDK.

Installation

dotnet add package Livekit.Rtc.Dotnet

Usage

Basic Connection

using LiveKit.Rtc;

var room = new Room();
await room.ConnectAsync("wss://your-livekit-server.com", "your-access-token",
    new RoomOptions { AutoSubscribe = true });

Console.WriteLine($"Connected to {room.Name}");
await room.DisconnectAsync();

Publishing Audio

var audioSource = new AudioSource(48000, 1); // 48kHz, mono
var audioTrack = LocalAudioTrack.Create("my-audio", audioSource);
var publication = await room.LocalParticipant!.PublishTrackAsync(audioTrack);

// Capture audio frames
var audioData = new short[480]; // 10ms at 48kHz
var audioFrame = new AudioFrame(audioData, 48000, 1, 480);
await audioSource.CaptureFrameAsync(audioFrame);

Publishing Video

var videoSource = new VideoSource(1920, 1080);
var videoTrack = LocalVideoTrack.Create("my-video", videoSource);
await room.LocalParticipant!.PublishTrackAsync(videoTrack);

// Capture video frames
var videoData = new byte[1920 * 1080 * 4]; // RGBA
var videoFrame = new VideoFrame(1920, 1080, Proto.VideoBufferType.Rgba, videoData);
videoSource.CaptureFrame(videoFrame);

Receiving Media

room.TrackSubscribed += async (sender, e) => {
    if (e.Track is RemoteVideoTrack videoTrack) {
        using var videoStream = new VideoStream(videoTrack);
        await foreach (var frame in videoStream.WithCancellation(cts.Token)) {
            // Process video frame
            Console.WriteLine($"Frame: {frame.Frame.Width}x{frame.Frame.Height}");
        }
    }
};

Event Handling

room.ParticipantConnected += (sender, participant) => {
    Console.WriteLine($"{participant.Identity} joined");
};

room.ActiveSpeakersChanged += (sender, e) => {
    Console.WriteLine($"Active speakers: {e.Speakers.Count}");
};

room.DataReceived += (sender, e) => {
    var message = Encoding.UTF8.GetString(e.Data);
    Console.WriteLine($"Data from {e.Participant.Identity}: {message}");
};

End-to-End Encryption

var key = new byte[32]; // AES-256 key
var options = new RoomOptions {
    E2EE = new E2EEOptions {
        KeyProviderOptions = new KeyProviderOptions { SharedKey = key }
    }
};

await room.ConnectAsync(url, token, options);
// All tracks automatically encrypted/decrypted

RPC Communication

// Register RPC method handler
room.LocalParticipant!.RegisterRpcMethod("greet", async (data) => {
    return $"Hello, {data.CallerIdentity}!";
});

// Call RPC method on another participant
var response = await room.LocalParticipant!.PerformRpcAsync(
    destinationIdentity: "other-participant",
    method: "greet",
    payload: "{}",
    responseTimeout: 5
);

Example apps

At LivekitRtc.Example you can find several example applications demonstrating the usage of LiveKit.Rtc.Dotnet SDK. See the examples README for more details.

For developers of the SDK

Clone repository

Make sure to clone with submodule option:

git clone --recurse-submodules https://github.com/pabloFuente/livekit-server-sdk-dotnet.git

Run tests

All E2E tests automatically launch necessary services as Docker containers with Testcontainers.

dotnet test LivekitRtc.Tests

Building from source

Prerequisites:

1. Get native FFI libraries

Option 1: download pre-compiled binaries from LiveKit Rust SDK releases

The easiest way to get the latest FFI binaries without building from source:

# From LivekitRtc directory
./download_ffi.sh          # Downloads latest version
./download_ffi.sh 0.12.44  # Or specify a version

This downloads pre-compiled binaries from LiveKit Rust SDK releases for all supported platforms (Windows, Linux, macOS on x64 and ARM64).

Option 2: building native libraries from source

If you want to modify the Rust/FFI code or use unreleased features. You will need:

# From LivekitRtc directory
git submodule update --init --recursive
cd rust-sdks/livekit-ffi
cargo build --release

After building, copy the native libraries from target/release/ to the appropriate runtimes/{rid}/native/ folders. Take into account that Rust builds for the host platform by default, so you may need to cross-compile for other platforms.

2. Generate Protocol Buffers

# From the root directory (livekit-server-sdk-dotnet/.)
./generate_proto.sh

3. Build the .NET SDK

# From LivekitRtc directory
dotnet build

Upgrade version of rust-sdks

To upgrade the version of the rust-sdks Git submodule:

cd rust-sdks
git fetch --all
git checkout <COMMIT_HASH/TAG/BRANCH> # e.g. git checkout livekit-ffi/v0.12.50
cd ..
./generate_proto.sh
dotnet pack -c Debug -p:IncludeSymbols=true -p:SymbolPackageFormat=snupkg

Then commit:

git commit -m "Update rust-sdks to <VERSION>"
git push

Perform release

  1. Create a commit for the new version updating the <Version> property in LivekitRtc.csproj.
  2. Make sure to run script ./build_local.sh to properly format all files with csharpier. Commit any changes in the repo after the script finishes.
  3. Create a new release in GitHub with:
    • Release title rtc-X.Y.Z
    • A new tag rtc-X.Y.Z
    • Description with relevant changes (e.g., Update to LiveKit Rust SDK vA.B.C)

Important

The rtc- prefix in the tag is mandatory for the publish workflow to identify that it is a release for package Livekit.Rtc.Dotnet specifically.

After creating the release, workflow publish.yml will automatically publish the new version to NuGet and will perform the necessary post-release tasks.