jitsi-videobridge

Jitsi Videobridge is a WebRTC compatible video router or SFU that lets build highly scalable video conferencing infrastructure (i.e., up to hundreds of conferences per server).

2,894

988

2,894

173

View on GitHub

Top Related Projects

bigbluebutton

8,541

Complete open source web conferencing system.

synapse

11,806

Synapse: Matrix homeserver written in Python/Twisted.

Quick Overview

Jitsi Videobridge is an open-source WebRTC Selective Forwarding Unit (SFU) that enables efficient multi-party video conferencing. It's a core component of the Jitsi Meet project, designed to handle the routing of video and audio streams between participants in a conference.

Pros

Scalable architecture capable of handling large numbers of concurrent users
Low latency and efficient bandwidth usage through selective forwarding
Integrates seamlessly with other Jitsi components for a complete video conferencing solution
Active development and community support

Cons

Complex setup and configuration for non-technical users
Requires significant server resources for large-scale deployments
Limited documentation for advanced customization
Dependency on other Jitsi components for full functionality

Code Examples

As Jitsi Videobridge is a server-side component and not a code library, there are no direct code examples for its usage. Instead, it is typically configured and interacted with through configuration files and APIs.

Getting Started

To get started with Jitsi Videobridge:

Install Java 11 or newer
Download the latest release from GitHub
Extract the archive
Configure the ~/.sip-communicator/sip-communicator.properties file
Run the videobridge:

./jvb.sh --apis=rest,xmpp

For a complete Jitsi Meet setup, refer to the official Jitsi documentation for detailed installation and configuration instructions.

Competitor Comparisons

bigbluebutton

8,541

Complete open source web conferencing system.

Pros of BigBlueButton

More comprehensive web conferencing solution with features like whiteboard, screen sharing, and breakout rooms
Better suited for educational environments with built-in learning management system (LMS) integrations
Offers recording and playback functionality out of the box

Cons of BigBlueButton

Higher resource requirements and more complex setup compared to Jitsi Videobridge
Less flexible for custom implementations or integrations into existing applications
Steeper learning curve for developers due to its more extensive codebase

Code Comparison

BigBlueButton (Ruby on Rails):

class Meeting < ActiveRecord::Base
  belongs_to :room
  has_many :participants
  has_many :recordings
end

Jitsi Videobridge (Java):

public class Conference implements PropertyChangeListener {
    private final String id;
    private final List<Endpoint> endpoints = new CopyOnWriteArrayList<>();
    private final BridgeChannelManager bridgeChannelManager;
}

BigBlueButton focuses on a full-featured web conferencing system with a Ruby on Rails backend, while Jitsi Videobridge is a more lightweight, Java-based video routing component. BigBlueButton's code reflects its broader scope with models for meetings, rooms, and recordings, whereas Jitsi Videobridge's code is more focused on managing video endpoints and conferences.

peerjs-server

4,349

Server for PeerJS

Pros of PeerJS Server

Lightweight and easy to set up for simple peer-to-peer connections
Supports WebRTC without the need for complex infrastructure
Can be easily integrated into existing Node.js applications

Cons of PeerJS Server

Limited scalability for large-scale video conferencing
Lacks advanced features like recording, transcoding, or load balancing
May not provide the same level of security and encryption as Jitsi Videobridge

Code Comparison

PeerJS Server (JavaScript):

const { PeerServer } = require('peer');

const peerServer = PeerServer({ port: 9000, path: '/myapp' });

peerServer.on('connection', (client) => {
  console.log(`Client connected: ${client.getId()}`);
});

Jitsi Videobridge (Java):

import org.jitsi.videobridge.Videobridge;

Videobridge videobridge = new Videobridge();
videobridge.start();

Conference conference = videobridge.createConference();
Endpoint endpoint = conference.createEndpoint();

The code snippets demonstrate the simplicity of setting up a PeerJS server compared to the more complex Jitsi Videobridge implementation. PeerJS Server is more suitable for basic peer-to-peer connections, while Jitsi Videobridge offers a robust solution for large-scale video conferencing with advanced features.

coturn

11,263

coturn TURN server project

Pros of coturn

More versatile, supporting multiple protocols (TURN, STUN, ICE) for various NAT traversal scenarios
Lightweight and efficient, suitable for a wide range of applications beyond video conferencing
Active development with frequent updates and improvements

Cons of coturn

Requires more configuration and setup compared to Jitsi Videobridge's out-of-the-box solution
Less integrated with a complete video conferencing ecosystem
May require additional components for full-featured video conferencing functionality

Code Comparison

coturn configuration example:

listening-port=3478
listening-ip=0.0.0.0
external-ip=203.0.113.5
user=myuser:mypassword
realm=example.com

Jitsi Videobridge configuration example:

org.ice4j.ice.harvest.STUN_MAPPING_HARVESTER_ADDRESSES=stun.l.google.com:19302
org.jitsi.videobridge.ENABLE_STATISTICS=true
org.jitsi.videobridge.STATISTICS_TRANSPORT=muc
org.jitsi.videobridge.xmpp.user.shard.HOSTNAME=localhost

While both projects serve different purposes in the WebRTC ecosystem, coturn offers more flexibility for various NAT traversal scenarios, whereas Jitsi Videobridge provides a more integrated solution specifically tailored for video conferencing applications. The code examples demonstrate the different configuration approaches, with coturn focusing on TURN server settings and Jitsi Videobridge emphasizing integration with its broader ecosystem.

janus-gateway

8,183

Janus WebRTC Server

Pros of Janus-gateway

Supports a wider range of protocols (WebRTC, RTMP, SIP, etc.)
More flexible architecture, allowing for easier customization and plugin development
Better suited for complex use cases beyond video conferencing

Cons of Janus-gateway

Steeper learning curve due to its more complex architecture
Less optimized for large-scale video conferencing compared to Jitsi-videobridge
May require more server resources for similar workloads

Code Comparison

Janus-gateway (C):

janus_plugin *create(void) {
    janus_plugin *plugin = (janus_plugin *)calloc(1, sizeof(janus_plugin));
    plugin->init = janus_videoroom_init;
    plugin->destroy = janus_videoroom_destroy;
    plugin->handle_message = janus_videoroom_handle_message;
    return plugin;
}

Jitsi-videobridge (Java):

public class Videobridge {
    public void handleColibriRequest(Conference conference, ColibriConferenceIQ request) {
        // Process the request and update the conference
    }
}

The code snippets show the different approaches: Janus-gateway uses a plugin-based architecture in C, while Jitsi-videobridge implements a more straightforward Java-based approach focused on video conferencing.

synapse

11,806

Synapse: Matrix homeserver written in Python/Twisted.

Pros of Synapse

Supports a wider range of communication features beyond video, including text messaging and file sharing
Offers end-to-end encryption for enhanced privacy and security
Provides a federated architecture, allowing for decentralized communication networks

Cons of Synapse

Generally requires more server resources and can be more complex to set up and maintain
May have higher latency for real-time video communication compared to Jitsi Videobridge
Less specialized for video conferencing, which could result in fewer video-specific optimizations

Code Comparison

Synapse (Python):

class FederationServlet(servlet.ServletBase):
    def __init__(self, hs):
        super(FederationServlet, self).__init__()
        self.homeserver = hs

Jitsi Videobridge (Java):

public class Videobridge
{
    public Videobridge()
    {
        this(new XmppConnection(), new DefaultConferenceFactory());
    }
}

Both projects use object-oriented programming, but Synapse is written in Python while Jitsi Videobridge is in Java. Synapse's code reflects its broader communication focus, while Jitsi Videobridge's code is more specifically tailored to video conferencing functionality.

openvidu

1,895

OpenVidu Platform main repository

Pros of OpenVidu

Easier to set up and use, with a more user-friendly API
Supports multiple platforms, including web, mobile, and desktop applications
Offers additional features like recording and screen sharing out of the box

Cons of OpenVidu

Less scalable for large-scale deployments compared to Jitsi Videobridge
More resource-intensive, potentially leading to higher hosting costs
Limited customization options compared to Jitsi Videobridge's flexibility

Code Comparison

OpenVidu (JavaScript):

var OV = new OpenVidu();
var session = OV.initSession();
session.connect(token)
    .then(() => console.log("Connected"))
    .catch(error => console.error(error));

Jitsi Videobridge (Java):

JitsiMeetConferenceOptions options = new JitsiMeetConferenceOptions.Builder()
    .setServerURL(new URL("https://meet.jit.si"))
    .setRoom("myRoom")
    .build();
JitsiMeetActivity.launch(this, options);

The code snippets demonstrate the initialization process for each platform. OpenVidu uses a JavaScript API, while Jitsi Videobridge employs Java for Android integration. OpenVidu's approach is more straightforward, but Jitsi Videobridge offers more granular control over the connection process.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

Intro

Jitsi Videobridge is a WebRTC-compatible Selective Forwarding Unit (SFU), i.e. a multimedia router. It is one of the backend components in the Jitsi Meet stack.

You can find more documentation in the doc/ directory in the source tree and in the Jitsi Meet Handbook.

If you have questions about the project, please post on the Jitsi Community Forum. GitHub issues are only used to track actionable items.

Packages

Debian/Ubuntu

You can download binary packages for Debian/Ubuntu:

Building your own package

You can build a custom package with just mvn install in the root directory of the repo. Look for the package in jvb/target/jitsi-videobridge-2.1-SNAPSHOT-archive.zip.

Running locally

You can run jitsi-videobridge locally with maven (or in your IDE). First create a ~/.jvb/jvb.conf to configure the environment to connect to and other options (see reference.conf for the available options).

JVB_HOME="/path/to/the/cloned/repo"
JVB_CONFIG_DIR_LOCATION="~/"
JVB_CONFIG_DIR_NAME=".jvb"
JVB_CONFIG_FILE="$JVB_CONFIG_DIR_LOCATION/$JVB_JVB_CONFIG_DIR_NAME/jvb.conf"

mvn compile exec:exec -Dexec.executable=java -Dexec.args="-cp %classpath org.jitsi.videobridge.MainKt -Djava.library.path=$JVB_HOME/lib/native/linux-64 -Djava.util.logging.config.file=$JVB_HOME/lib/logging.properties -Dnet.java.sip.communicator.SC_HOME_DIR_LOCATION=$JVB_CONFIG_DIR_LOCATION -Dnet.java.sip.communicator.SC_HOME_DIR_NAME=$JVB_CONFIG_DIR_NAME -Dconfig.file=$JVB_CONFIG_FILE"

Configuration

Application level configuration comes from a config file, usually installed in /etc/jitsi/videobridge/jvb.conf. The values in that file override the defaults defined in reference.conf.

Debian

On debian systems the /etc/jitsi/videobridge/config file can be used to set configuration for the Java virtual machine. Notable examples:

# Increase the java heap to 8GB
VIDEOBRIDGE_MAX_MEMORY=8192m
# Change the garbage collector (defaults to G1GC)
VIDEOBRIDGE_GC_TYPE=G1GC

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot