December 8, 2018

717 words 4 mins read



Scalable peer to peer live video streaming built on torrents and webRTC

repo name gitsummore/nile.js
repo link
language JavaScript
size (curr.) 1389 kB
stars (curr.) 1714
created 2017-04-27
license MIT License


A tool for scalable peer-to-peer video streaming using WebTorrent.

NOTE: This project is no longer being actively maintained

Why WebTorrent?

By using the collective power of WebTorrent, video streams get progressively stronger as more peers contribute to a torrent. With torrents, it is also possible for users to access previous parts of a stream unlike traditional WebRTC video streaming.



This is the plug-and-play middleware that receives the torrent link from the broadcasting client and sets up the proper connections for the viewing clients.


This is the client component that records video from a device’s camera, saving it to generated torrent files, and sending those torrents' magnet link out to the viewing clients.


This is the client which views what the Broadcaster is recording. It receives a torrent magnet link and renders the video from that torrent to an injected video tag using WebTorrent.



Nile.js utilizes Express middleware and to receive torrent information, broadcast it to as many clients it can comfortably handle who will then send it out to the rest of the clients.

To use it, require nileServer from our package and pass in the Node Server instance you’re using. In Express, you can get this instance by calling app.listen.

You’ll also need to pass in the number of WebSockets the server has to maintain. Let’s use 10 for now.

Here’s how you would use it in your server:

const server = app.listen(8000);
const socketLimit = 10;
const nileServer = require('nile.js/nileServer')(server, 10);

Now add the nile.js middleware w/ app.use:

app.use('/', nileServer);

Note that this middleware will use a “magnet” route to accept POST requests with the magnet link from the Broadcaster.



If using a file bundler e.g. (webpack), you may import the module.

import { Broadcaster } from 'nile.js'

If you just want to test the module without bundling, it is currently being hosted on unpkg CDN. Use it as a script in your html file.

4 parameters:

  1. recordInterval - The Interval that the webcam recording should seed each segment of the video (ms)
  2. videoNodeIDForPlayback - The id of the video node in the html where the broadcaster can see their own recording
  3. startStreamID - The id of the button node that BEGINS the recording/live streaming
  4. stopStreamID - The id of the button node that ENDS the recording/live streaming

The Broadcaster object is used to stream video to a torrent and send the torrent link to the server and then to the network of viewers.

Because torrents are immutable, we approximate streaming with torrents by setting a recordInterval, in milliseconds. This sets how long each clip will be before being sent via torrent. From our experience, we recommend an interval 6000-10000 (6-10 seconds).

Next, pass in the ID of the video tag you’d like to view your recording playback from as well as button IDs for the starting and stopping the stream.


const broadcaster = new Broadcaster(8000, 'video', 'button-play-gum', 'button-stop-gum');


If using a file bundler e.g. (webpack), you may import the module.

import { Viewer } from 'nile.js'

If you just want to test the module without bundling, it is currently being hosted on unpkg CDN. Use it as a script in your html file.

2 parameters:

  1. ID_of_NodeToRenderVideo - ID of DOM element to render live feed to
  2. addedIceServers - Array of extra WebRTC ICE servers, based on this interface laid out by W3C

The Viewer object receives torrent links from or RTCDataChannel connections and progressively renders the videos from the torrents to the supplied ID, ID_of_NodeToRenderVideo.


const viewer = new Viewer('videos');

The Viewer maintains two WebRTC connections, one to a parent (client closest to server) and a child client (farther from server). These two connections create a chain of clients that propagate server-sent torrent information down to subsequent viewers down the chain.

In the event of a client disconnecting, the disconnecting Viewer will let its immediate child client know and tell it to reconnect to its parent. This maintains network integrity and ensures that the stream will still reach every client in that chain.

comments powered by Disqus