Real-time communication (RTC) is a cornerstone of video call services and online gaming apps like Zoom or Google Meet. It allows you to see and talk with others in real time over the Internet. One of the early solutions for RTC development is libjingle, a library that enables developers to build real-time video and voice features. Using libjingle for real-time communication allows you to create effective communication apps with peer-to-peer connectivity.
Do you want to learn about libjingle, from how it works to how to install this software to develop video and voice applications? This article is the right place for you to find them out. Keep reading and explore!
libjingle is a C++ library. Although it has some components written in other languages, its core is written in C++ and mainly handles the most difficult tasks of RTC, like signaling, media processing, or NAT traversal. This is why performance-critical apps that require fine-grained control over the RTC process often depend on libjingle.
Originally, libjingle was developed by Google to allow for video and voice calls in Google Talk, which is one of its first VoIP and instant messaging services. The library offers the necessary functionalities to create smooth, direct connections between users without the need for a central server. For example, it uses protocols like XMPP (Extensible Messaging and Presence Protocol) for signaling and ICE (Interactive Connectivity Establishment) for managing connections.
When technology evolved, Google integrated libjingle’s core features, especially those related to signaling and peer connection, into a broader framework called WebRTC. While libjingle is no longer actively maintained as a separate entity, its code and concepts are integral parts of WebRTC, laying the foundation for today’s RTC solutions.
To better understand libjingle, it’s essential to learn about its key features and how these features work together to establish seamless calls and data exchange. Let’s take a look:
Before transmitting any media, devices need to find each other, agree upon a communication protocol, and exchange session details. This is what we call a “signaling process.”
libjingle supports signaling between two devices through protocols. XMPP is a widely used protocol that sends connection requests and manages presence updates. Further, developers can implement custom signaling methods to exchange session description protocol (SDP) information, including supported codecs, media types, and other parameters.
In P2P communication, devices need to create a direct connection for efficient data exchange and calls. However, many devices sit behind routers or firewalls that leverage Network Address Translation (NAT) to assign unique IP addresses. For this reason, two devices behind different NATs can’t easily connect, consequently blocking direct P2P connections. To address this problem, libjingle uses:
When devices are connected, they need to negotiate the media codecs and formats. To process real-time video and voice streaming, libjingle encodes and compresses media data to decrease bandwidth usage. Then, it uses RTP (Real-time Transport Protocol) to transfer media streams (audio and video) between devices.
libjingle keeps communication between devices stable by managing network conditions. This means it can adjust audio and video quality based on network conditions to keep connections stable. It’s especially beneficial when your users have a slow internet connection. Accordingly, libjingle can adapt to ensure clear video or voice calls without requiring additional plugins or complex configurations.
Further, it offers RTCP (Real-time Transport Control Protocol) to send feedback on the quality of the media stream. This allows devices to manage packet loss and jitter to prevent call disruptions. Meanwhile, the library supports data encryption to safeguard user privacy and avoid unauthorized access.
It’s crucial to restate that libjingle is no longer supported and recommended for new real-time communication projects. Instead, WebRTC is preferred and has become a standard in RTC development. Therefore, this section is primarily for educational purposes, which helps you understand the evolution of RTC technology. In other words, we don’t encourage you to use libjingle for a production application.
Prior to libjingle installation, you need to prepare your development environment and set up essential dependencies.
libjingle can be installed on Windows, macOS, and Linux. However, each operating system requires different tools and commands to implement setup.
Windows
macOS
Linux (Ubuntu/Debian)
sudo apt-get update
sudo apt-get install git make
build-essential, libssl-dev, or pkg-config.To create and run libjingle, you need the following dependencies:
sudo apt-get install build-essential.
sudo apt-get install protobuf-compiler # Linux (Ubuntu/Debian)
brew install protobuf # macOS (using Homebrew)
To install and run libjingle, you can follow these steps. However, please remember that these steps are general instructions. The specific commands and directory structures can vary depending on the exact libjingle version you’re working on.
First, you need to replicate the libjingle repository (if you can find a still-accessible one) using Git from Google’s source. Open a terminal and run the following command:
git clone https://some.accessible.libjingle.repo.url/libjingle.git # Hypothetical URL
When you already have the repository, it’s time to install all the essential dependencies we listed above. The process may vary depending on your environment.
On Windows: The installation process for Windows can include many steps, typically setting up Visual Studio, GN/Ninja, and WebRTC dependencies. You should consult the WebRTC documentation or official libjingle (if available) to access Windows-specific instructions.
On macOS/Linux: After cloning the repository, you need to navigate to the libjingle directory and set up the essential dependencies by running the appropriate setup script (if available) for your operating system. If no script is provided, you must manually install these dependencies (e.g., WebRTC dependencies or protobuf).
Once you set up the development environment and all the required dependencies, the next step is to create libjingle from the source code. This includes compiling the source files and linking them with the essential dependencies to create the final libraries for use in real-time communication apps.
In this step, you first navigate to the libjingle source directory with the following command:
cd path/to/libjingle
Note: Replace path/to/libjingle with the actual directory where you already replicated the repository.
Next, compile the library with build systems like GN, Ninja, or GYP (an older version of libjingle). When the build is finished, you should check the output directory for the compiled binaries. In doing so, search for files like static libraries (.a or .lib files) or shared libraries (.dll for Windows and .so for macOS/Linux)
To ensure your build is successful, we advise you to run a sample libjingle test program with the following script:
./out/Default/peerconnection_server
If you see logs stating that the peer connection server is running, it means your build is successful. In other words, you correctly compiled libjingle and this library is ready for incorporation into your real-time communication apps.
In this section, we’ll also offer a conceptual overview of common issues and debugging approaches that are related to libjingle apps. Even when libjingle isn’t a separate entity yet a crucial part of WebRTC, understanding problems relevant to libjingle is still essential. This is especially beneficial if you use libjingle in WebRTC-based applications.
When this problem occurs, you may notice that devices fail to connect with each other, calls often drop, or signaling messages are not correctly exchanged.
Possible causes can be issues with the signaling server, NAT traversal failures, incorrect network configurations, and restrictive firewalls. By identifying the exact culprit behind connection failures, you can implement appropriate troubleshooting strategies like verifying the signaling server logs or inspecting ICE candidate fathering.
When this problem happens, your devices might confront choppy and laggy media streams. The reasons behind this may vary. Limited bandwidth, hardware limitations, codec mismatch, and network congestion can impact the quality of video calls or data exchange.
Once you’ve identified the precise cause, you can implement proper troubleshooting techniques. They can involve estimating bandwidth to adapt the media stream, checking hardware (e.g., camera or microphone), testing whether compatible codecs are used, and more.
This problem occurs when devices are unlikely to gather ICE candidates, which are crucial to creating a connection. The reasons behind this issue can come from network restrictions (e.g., firewalls blocking access), incorrect configuration, and STUN/TURN server problems. When you identify the correct cause, you can implement suitable troubleshooting measures like testing STUN/TURN connectivity or inspecting ICE candidate logs.
In addition to troubleshooting strategies and techniques, you should combine the use of tools to debug libjingle applications.
As we confirm throughout this article, libjingle is no longer maintained and supported as a standalone technology. Therefore, it’s clear that this library has no future in modern real-time communication projects.
While some legacy systems can still leverage libjingle, most modern apps have switched to WebRTC because of its better performance and active support. Developers also consider transitioning their old projects built with libjingle to WebRTC if they want to maintain these projects with feature improvements.
WebRTC is a W3C framework that offers an all-inclusive set of APIs to develop real-time communication apps in web browsers and other platforms. Look at the following table to understand why WebRTC is preferred over libjingle:
| Feature | libjingle | WebRTC |
| Platform Support | Limited (Desktop) | Cross-platform (Web, Mobile, Desktop) |
| Media Handling | Basic | Optimized with VP8/VP9, Opus |
| NAT Traversal | STUN/TURN | Advanced ICE/STUN/TURN |
| Security | Limited encryption | End-to-end encryption, DTLS-SRTP |
| Scalability | Less optimized | Supports SFUs and MCUs for large-scale apps |
| Integration | Needs custom signaling | Works with modern signaling frameworks |
| Maintenance | Unsupported | Actively maintained |
So, does this mean learning about libjingle is meaningless? We would say not exactly. As Google moved it to WebRTC, which integrates the core functionalities of libjingle, understanding this library will lay the groundwork for learning about some parts of WebRTC. Further, there are still some cases where developers still consider libjingle. This is when you want to maintain legacy apps that were initially built with libjingle or non-browser-based apps where WebRTC’s browser dependencies are unnecessary.
Switching from libjingle to WebRTC is a daunting process. It often requires rewriting significant portions of your app’s communication logic. As libjingle depends on external signaling, you need to re-architect how signaling works in your app to leverage the signaling mechanisms offered by WebRTC. Further, you need to adapt the media handling to the WebRTC APIs.
After this article, we expect you to better understand what libjingle is and how it works for real-time communication applications. Although it’s now no longer supported and maintained, its core functionalities still prove useful in WebRTC-based apps. For more interesting articles about VoIP technologies, subscribe to our blog now and follow us on Facebook, X, and LinkedIn!
Also published on
Share post on
