Open-source project
versatica/mediasoup avatar
versatica/mediasoup

mediasoup: an SFU that deliberately handles only the media layer

Cutting Edge WebRTC Video Conferencing

7,421 stars1,256 forksC++ISC

At a glance

What is it?
mediasoup is a selective forwarding unit for WebRTC, published both as a Node.js module and as a Rust crate over one C++ media worker built on libuv. The design goals are unusually explicit about what it will not do: no mandated signaling protocol, a low level API, nothing but the media layer. The consequences show up in the shape of the repository, which carries ten continuous integration workflows including a fuzzer for the native worker and a CodeQL static analysis pass.
Who is it for?
Adopt it when you are building an SFU yourself and want a media layer with congestion control, bandwidth estimation and simulcast already solved, and when you can live with writing your own signaling and session model. Do not adopt it as a conferencing product or as a peer-to-peer library, since forwarding rather than connecting is the architecture.
Can I use it commercially?
Yes. ISC is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly C++, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • versatica/mediasoup7,421 ★ · +46
Star history
Repository2026-09-232026-11-15
versatica/mediasoup7.4k7.4k

46 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The design goals start with what it refuses to do

The goals list reads like a set of boundaries. It should be a selective forwarding unit. It should support both WebRTC and plain RTP input and output. On the server side it should be a Node.js module or a Rust crate, and on the client side a tiny TypeScript and C++ library. And then the three that shape your project: it should be minimalist, handling just the media layer; it should be signaling agnostic, mandating no signaling protocol; and it should expose a super low level API. One more goal is easy to underestimate, because it is a compatibility promise rather than a feature: it should support all existing WebRTC endpoints. Taken together, the message is that everything above the media path is yours.

Two server bindings, one native worker, and the tree says which is which

The repository is three codebases and a build system. There is a directory for the Node library, one for the Rust crate, and one for the C++ worker, and the manifest for the native side declares a workspace whose members are the Rust crate, its types package and the worker. The feature list describes the worker as a media worker thread or subprocess coded in C++ on top of the libuv event loop, which is where the performance claim is aimed. So the architecture is a low level API in your language of choice over a native core that owns the sockets. Two consequences follow. If you prototype in Node and move to Rust for throughput, you rewrite the application layer, because there is no shared binding. And if you deploy containers, the native worker and its build are part of what you ship, not an implementation detail behind a package manager.

The Rust crate carries its own version line

Look at the recent releases and the numbering splits. The Node package is at 3.32.1, published 2026-10-30, and on the same day there is a separate release for the Rust crate at rust-0.33.1, after 3.32.0 on 2026-10-26. Two publish pipelines follow from that, one for the npm registry and one for the crate registry, and the versions are not derived from each other. For a team that runs both a Node service and a Rust service, this is the practical point: you cannot say we are both on the same release, and a feature that lands in one runtime may not be in the other on the same day. The consequence for dependency management is that each side needs its own pin and its own upgrade decision, and the major version of the library does not describe the state of either one on its own.

Multiple streams deliberately share one transport

The transport design is the part with the most opinion in it. The library supports multiple audio and video streams over a single ICE and DTLS transport, so adding a camera does not add a connection. It supports simulcast and scalable video coding, so a sender can offer several resolutions and the forwarder picks. There is congestion control, and sender and receiver bandwidth estimation driven by an algorithm that distributes spatial and temporal layers. Transport runs ICE, DTLS, RTP and RTCP over both UDP and TCP, and the stack is IPv6 ready. Data channels are handled three ways: the normal WebRTC data channel, SCTP directly over plain UDP, and direct termination inside Node.js or Rust. So the assumption is a server that forwards many tracks over few transports, which is what a selective forwarding unit is for, and it is why the use cases listed are group video chat, one-to-many or few-to-many broadcasting, and RTP streaming.

Ten workflows, and two of them exist because the worker parses untrusted media

The badges at the top of the readme are a map of the engineering effort, and there are ten of them: builds for Node, the worker and Rust, a fuzzer workflow for the worker, a workflow that prebuilds the worker, publish jobs for both registries, update jobs for the website and the demo, and a static analysis workflow. Two of those deserve a second look. A fuzzer aimed at the media worker is a statement about where the risk sits, because that code parses and forwards data arriving from the network. And the CodeQL workflow adds static analysis. The consequence for an adopter is that the native component is treated as the risky part of the system rather than as plumbing, which is a good sign about how it is maintained and a reminder that your security review should not stop at your own application code.

The npm package ships the worker's sources, and the module floor is Node 22

The published file list is longer than you would expect for a native binding. Alongside the changelog, licence, readme and the built Node library, it includes the worker's makefile, FlatBuffers definitions, fuzzer headers and sources, mock headers and sources, the worker's own include and source trees, build scripts in four languages, subproject wrap files, tests, and the Meson build files. That is deliberate: the tarball can rebuild the native part rather than requiring a matching prebuilt binary. The export map is correspondingly explicit, with the root entry plus separate subpaths for types, errors, the ORTC layer and extras. The engine floor is Node 22 or newer. And the default branch is the version 3 branch rather than master, which is worth knowing before you file anything. The licence is ISC, funding goes through an open collective page, questions go to a support forum, and a hosted demo with its own source repository exists.

Editorial conclusion

Adopt it when you are building an SFU yourself and want a media layer with congestion control, bandwidth estimation and simulcast already solved, and when you can live with writing your own signaling and session model. Do not adopt it as a conferencing product or as a peer-to-peer library, since forwarding rather than connecting is the architecture. Before you commit, decide between the Node and Rust bindings knowing they are versioned separately, confirm your Node runtime is 22 or newer, and read the worker build notes, since the native part is what your deployment has to carry.

Frequently asked questions

what is mediasoup

An SFU, a selective forwarding unit, for WebRTC video conferencing. It supports both WebRTC and plain RTP input and output, runs server side as a Node.js module or a Rust crate over a C++ media worker built on libuv, ships tiny TypeScript and C++ client libraries, and is deliberately minimal: it handles the media layer, mandates no signaling protocol, and exposes a low level API.

how to use mediasoup

Pick the Node.js module or the Rust crate, since both drive the same native worker, then build on a low level API over ICE, DTLS, RTP and RTCP across UDP and TCP. Multi-stream, simulcast, congestion control and bandwidth estimation are handled for you, and because the library is signaling agnostic you supply the signaling protocol, the session model and the rest of your application.

is mediasoup free

The project is licensed under ISC and is published to the npm registry and to the crate registry. The two are versioned separately, so the Node package and the Rust crate are not on a single version number, and the project takes sponsorship through an open collective page rather than selling licences.

is mediasoup open source

Yes. The code is in the repository under the ISC licence, on the version 3 branch rather than master. Documentation lives on the project website, questions go to a support forum, and an online demo is published as a separate repository so you can read a working integration before writing your own.

Official sources

  1. License: ISC
  2. Project website
  3. README
  4. Releases
  5. versatica/mediasoup on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/versatica-mediasoup.svg)](https://hysenlabs.com/projects/versatica-mediasoup)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/versatica-mediasoup.svg)](https://hysenlabs.com/projects/versatica-mediasoup)

Was this useful?