Convert Figma logo to code with AI

feross logosimple-peer

📡 Simple WebRTC video, voice, and data channels

7,357
972
7,357
125
View on GitHubView on NPM

Top Related Projects

webrtc's avatar

samples

13,895

WebRTC Web demos and samples

peers's avatar

peerjs

12,311

Simple peer-to-peer with WebRTC.

webtorrent's avatar

webtorrent

29,431

⚡️ Streaming torrent client for the web

node-webrtc's avatar

node-webrtc

2,712

node-webrtc is a Node.js Native Addon that provides bindings to WebRTC M87

muaz-khan's avatar

WebRTC-Experiment

11,714

WebRTC, WebRTC and WebRTC. Everything here is all about WebRTC!!

coturn's avatar

coturn

11,072

coturn TURN server project

Quick Overview

Simple-peer is a WebRTC library that simplifies peer-to-peer connections in the browser and Node.js. It provides an easy-to-use API for creating data channels and media streams between peers, abstracting away much of the complexity of the WebRTC protocol.

Pros

  • Easy to use API for WebRTC connections
  • Works in both browser and Node.js environments
  • Supports data channels and media streams
  • Well-maintained and actively developed

Cons

  • Limited advanced WebRTC features compared to native APIs
  • May have slightly higher overhead due to abstraction layer
  • Requires additional signaling mechanism for peer discovery

Code Examples

Creating a peer connection:

import Peer from 'simple-peer'

const peer = new Peer({
  initiator: true,
  trickle: false
})

peer.on('signal', data => {
  console.log('Signal data:', data)
  // Send this data to the remote peer
})

peer.on('connect', () => {
  console.log('Peer connection established')
})

Sending and receiving data:

// Sending data
peer.send('Hello, remote peer!')

// Receiving data
peer.on('data', data => {
  console.log('Received:', data.toString())
})

Adding a video stream:

navigator.mediaDevices.getUserMedia({ video: true, audio: true })
  .then(stream => {
    peer.addStream(stream)
  })

peer.on('stream', stream => {
  // Display the remote video stream
  const video = document.createElement('video')
  video.srcObject = stream
  video.play()
  document.body.appendChild(video)
})

Getting Started

  1. Install the library:

    npm install simple-peer

  2. Create a new peer connection:

    import Peer from 'simple-peer'

const peer = new Peer({
  initiator: location.hash === '#init',
  trickle: false
})

peer.on('signal', data => {
  console.log('SIGNAL', JSON.stringify(data))
  // Send this data to the remote peer via your signaling mechanism
})

peer.on('connect', () => {
  console.log('CONNECT')
  peer.send('Hello from simple-peer!')
})

peer.on('data', data => {
  console.log('Received:', data.toString())
})

  3. Connect peers by exchanging signaling data between them using your preferred method (e.g., WebSocket, server API, etc.).

Competitor Comparisons

webrtc logo

samples

13,895

WebRTC Web demos and samples

Pros of WebRTC Samples

  • Comprehensive collection of WebRTC examples covering various use cases
  • Official repository maintained by the WebRTC project, ensuring up-to-date and standard-compliant implementations
  • Includes demos for advanced features like screen sharing, data channels, and device selection

Cons of WebRTC Samples

  • Primarily focused on demonstrating WebRTC features rather than providing a ready-to-use library
  • May require more setup and configuration for integration into projects
  • Less abstraction, potentially leading to more complex implementation for beginners

Code Comparison

WebRTC Samples (basic peer connection):

const pc = new RTCPeerConnection(configuration);
pc.onicecandidate = e => {
  if (e.candidate) {
    // Send candidate to peer
  }
};

Simple Peer:

const peer = new SimplePeer({ initiator: true });
peer.on('signal', data => {
  // Send signal data to peer
});

Summary

WebRTC Samples provides a comprehensive set of examples for various WebRTC features, maintained by the official WebRTC project. It's excellent for learning and exploring WebRTC capabilities but may require more effort to integrate into projects. Simple Peer, on the other hand, offers a more abstracted and easy-to-use API for basic WebRTC functionality, making it simpler for beginners to implement peer-to-peer connections quickly.

peers logo

peerjs

12,311

Simple peer-to-peer with WebRTC.

Pros of PeerJS

  • Higher-level abstraction, simplifying WebRTC implementation
  • Built-in signaling server option for easier setup
  • Extensive documentation and examples

Cons of PeerJS

  • Less flexibility for custom configurations
  • Larger bundle size due to additional features
  • Less frequent updates and maintenance

Code Comparison

simple-peer:

const peer = new SimplePeer({ initiator: true })
peer.on('signal', data => {
  // Send signaling data to peer
})
peer.on('connect', () => {
  peer.send('Hello, peer!')
})

PeerJS:

const peer = new Peer()
const conn = peer.connect('peer-id')
conn.on('open', () => {
  conn.send('Hello, peer!')
})

Summary

simple-peer offers a lightweight, flexible solution for WebRTC, ideal for developers who need fine-grained control. PeerJS provides a more abstracted, user-friendly approach, suitable for quick implementations and beginners. simple-peer requires manual signaling setup, while PeerJS includes a built-in option. Both libraries enable peer-to-peer communication, but PeerJS sacrifices some customization for ease of use. Choose based on your project's complexity and requirements.

webtorrent logo

webtorrent

29,431

⚡️ Streaming torrent client for the web

Pros of WebTorrent

  • Full-featured BitTorrent client implementation for the web
  • Supports streaming of audio/video content
  • Includes a comprehensive API for advanced use cases

Cons of WebTorrent

  • Larger codebase and more complex to implement
  • Higher resource usage due to additional features
  • May be overkill for simple peer-to-peer connections

Code Comparison

WebTorrent example:

const client = new WebTorrent()
client.seed(files, (torrent) => {
  console.log('Client is seeding:', torrent.infoHash)
})

simple-peer example:

const peer = new SimplePeer({ initiator: true })
peer.on('signal', (data) => {
  // send signal data to peer
})

Key Differences

  • WebTorrent is a complete BitTorrent client, while simple-peer focuses on WebRTC peer connections
  • simple-peer is more lightweight and easier to integrate for basic peer-to-peer functionality
  • WebTorrent offers more features like torrent creation, seeding, and content streaming
  • simple-peer provides a simpler API for direct peer connections without the overhead of BitTorrent protocol

Use Cases

  • Choose WebTorrent for building web-based torrent clients or applications requiring BitTorrent functionality
  • Opt for simple-peer when implementing basic WebRTC peer-to-peer connections or data channels in web applications
node-webrtc logo

node-webrtc

2,712

node-webrtc is a Node.js Native Addon that provides bindings to WebRTC M87

Pros of node-webrtc

  • Native C++ implementation, potentially offering better performance
  • Provides lower-level access to WebRTC APIs
  • Supports more advanced WebRTC features and configurations

Cons of node-webrtc

  • Steeper learning curve due to lower-level API
  • Requires more setup and configuration
  • Less abstraction, which may lead to more complex code for simple use cases

Code Comparison

node-webrtc:

const wrtc = require('wrtc');
const pc = new wrtc.RTCPeerConnection();
pc.createOffer().then(offer => {
  pc.setLocalDescription(offer);
});

simple-peer:

const Peer = require('simple-peer');
const peer = new Peer({ initiator: true });
peer.on('signal', data => {
  // send signal data to peer
});

Summary

node-webrtc provides a more comprehensive and lower-level approach to WebRTC in Node.js, offering greater control and advanced features. However, it comes with increased complexity and setup requirements. simple-peer, on the other hand, offers a more user-friendly API with higher-level abstractions, making it easier to implement basic WebRTC functionality quickly. The choice between the two depends on the specific requirements of your project and the level of control you need over WebRTC operations.

muaz-khan logo

WebRTC-Experiment

11,714

WebRTC, WebRTC and WebRTC. Everything here is all about WebRTC!!

Pros of WebRTC-Experiment

  • More comprehensive, offering a wider range of WebRTC features and demos
  • Includes server-side implementations for various programming languages
  • Provides extensive documentation and examples for different use cases

Cons of WebRTC-Experiment

  • Less focused and potentially more complex for simple peer-to-peer connections
  • May have a steeper learning curve due to its broader scope
  • Not as actively maintained as Simple-peer (last update was longer ago)

Code Comparison

Simple-peer example:

const peer = new SimplePeer({ initiator: true })
peer.on('signal', data => {
  // send signal data to peer
})
peer.on('connect', () => {
  peer.send('hello')
})

WebRTC-Experiment example:

var connection = new RTCMultiConnection();
connection.socketURL = 'https://rtcmulticonnection.herokuapp.com:443/';
connection.session = {
  audio: true,
  video: true
};
connection.openOrJoin('room-id');

The Simple-peer example demonstrates a more straightforward approach for basic peer-to-peer connections, while the WebRTC-Experiment example showcases its ability to handle more complex scenarios with built-in signaling and room management.

coturn logo

coturn

11,072

coturn TURN server project

Pros of coturn

  • Comprehensive TURN/STUN server implementation with extensive features
  • Supports multiple protocols (UDP, TCP, TLS, DTLS)
  • Highly scalable and suitable for enterprise-level deployments

Cons of coturn

  • More complex setup and configuration compared to simple-peer
  • Requires server infrastructure and maintenance
  • Steeper learning curve for beginners

Code comparison

simple-peer (client-side WebRTC):

const peer = new SimplePeer({ initiator: true })
peer.on('signal', data => {
  // send signal data to peer
})
peer.on('connect', () => {
  peer.send('Hello, peer!')
})

coturn (server configuration):

listening-port=3478
tls-listening-port=5349
realm=example.com
server-name=turnserver
user=myuser:mypassword

Summary

simple-peer is a lightweight WebRTC library for peer-to-peer connections in JavaScript, ideal for quick implementations and client-side use. coturn, on the other hand, is a full-featured TURN/STUN server implementation, offering robust NAT traversal solutions for WebRTC applications. While simple-peer focuses on ease of use for developers, coturn provides a comprehensive server-side solution with greater scalability and protocol support, but requires more setup and maintenance.

Convert Figma logo designs to code with AI

Visual Copilot

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

Try Visual Copilot

README

simple-peer ci coveralls npm downloads javascript style guide javascript style guide

Simple WebRTC video, voice, and data channels

Sponsored by    DFINITY

We are hiring a peer-to-peer WebRTC mobile Web application expert.

DFINITY is building an exciting peer-to-peer WebRTC-based mobile Web app to help improve democracy on the Internet Computer blockchain. The mobile web app connects groups of up to four people in a peer-to-peer WebRTC audio and video call so that they can mutually prove unique personhood.

We are looking for a software engineer or consultant who can help us solve (platform-dependent) reliability issues of our implementation. We are interested in applicants with substantial WebRTC experience for mobile Web apps, experience with different communication patterns (e.g., peer-to-peer, server relay), and substantial problem-solving skills. Having experience in automated testing of this type of applications is a plus. Pay is extremely competitive for the right expertise. For details, please see the full job description.

features

  • concise, node.js style API for WebRTC
  • works in node and the browser!
  • supports video/voice streams
  • supports data channel
  • supports advanced options like:

This package is used by WebTorrent and many others.

install

npm install simple-peer

This package works in the browser with browserify. If you do not use a bundler, you can use the simplepeer.min.js standalone script directly in a <script> tag. This exports a SimplePeer constructor on window. Wherever you see Peer in the examples below, substitute that with SimplePeer.

usage

Let's create an html page that lets you manually connect two peers:

<html>
  <body>
    <style>
      #outgoing {
        width: 600px;
        word-wrap: break-word;
        white-space: normal;
      }
    </style>
    <form>
      <textarea id="incoming"></textarea>
      <button type="submit">submit</button>
    </form>
    <pre id="outgoing"></pre>
    <script src="simplepeer.min.js"></script>
    <script>
      const p = new SimplePeer({
        initiator: location.hash === '#1',
        trickle: false
      })

      p.on('error', err => console.log('error', err))

      p.on('signal', data => {
        console.log('SIGNAL', JSON.stringify(data))
        document.querySelector('#outgoing').textContent = JSON.stringify(data)
      })

      document.querySelector('form').addEventListener('submit', ev => {
        ev.preventDefault()
        p.signal(JSON.parse(document.querySelector('#incoming').value))
      })

      p.on('connect', () => {
        console.log('CONNECT')
        p.send('whatever' + Math.random())
      })

      p.on('data', data => {
        console.log('data: ' + data)
      })
    </script>
  </body>
</html>

Visit index.html#1 from one browser (the initiator) and index.html from another browser (the receiver).

An "offer" will be generated by the initiator. Paste this into the receiver's form and hit submit. The receiver generates an "answer". Paste this into the initiator's form and hit submit.

Now you have a direct P2P connection between two browsers!

A simpler example

This example create two peers in the same web page.

In a real-world application, you would never do this. The sender and receiver Peer instances would exist in separate browsers. A "signaling server" (usually implemented with websockets) would be used to exchange signaling data between the two browsers until a peer-to-peer connection is established.

data channels

var Peer = require('simple-peer')

var peer1 = new Peer({ initiator: true })
var peer2 = new Peer()

peer1.on('signal', data => {
  // when peer1 has signaling data, give it to peer2 somehow
  peer2.signal(data)
})

peer2.on('signal', data => {
  // when peer2 has signaling data, give it to peer1 somehow
  peer1.signal(data)
})

peer1.on('connect', () => {
  // wait for 'connect' event before using the data channel
  peer1.send('hey peer2, how is it going?')
})

peer2.on('data', data => {
  // got a data channel message
  console.log('got a message from peer1: ' + data)
})

video/voice

Video/voice is also super simple! In this example, peer1 sends video to peer2.

var Peer = require('simple-peer')

// get video/voice stream
navigator.mediaDevices.getUserMedia({
  video: true,
  audio: true
}).then(gotMedia).catch(() => {})

function gotMedia (stream) {
  var peer1 = new Peer({ initiator: true, stream: stream })
  var peer2 = new Peer()

  peer1.on('signal', data => {
    peer2.signal(data)
  })

  peer2.on('signal', data => {
    peer1.signal(data)
  })

  peer2.on('stream', stream => {
    // got remote video stream, now let's show it in a video tag
    var video = document.querySelector('video')

    if ('srcObject' in video) {
      video.srcObject = stream
    } else {
      video.src = window.URL.createObjectURL(stream) // for older browsers
    }

    video.play()
  })
}

For two-way video, simply pass a stream option into both Peer constructors. Simple!

Please notice that getUserMedia only works in pages loaded via https.

dynamic video/voice

It is also possible to establish a data-only connection at first, and later add a video/voice stream, if desired.

var Peer = require('simple-peer') // create peer without waiting for media

var peer1 = new Peer({ initiator: true }) // you don't need streams here
var peer2 = new Peer()

peer1.on('signal', data => {
  peer2.signal(data)
})

peer2.on('signal', data => {
  peer1.signal(data)
})

peer2.on('stream', stream => {
  // got remote video stream, now let's show it in a video tag
  var video = document.querySelector('video')

  if ('srcObject' in video) {
    video.srcObject = stream
  } else {
    video.src = window.URL.createObjectURL(stream) // for older browsers
  }

  video.play()
})

function addMedia (stream) {
  peer1.addStream(stream) // <- add streams to peer dynamically
}

// then, anytime later...
navigator.mediaDevices.getUserMedia({
  video: true,
  audio: true
}).then(addMedia).catch(() => {})

in node

To use this library in node, pass in opts.wrtc as a parameter (see the constructor options):

var Peer = require('simple-peer')
var wrtc = require('wrtc')

var peer1 = new Peer({ initiator: true, wrtc: wrtc })
var peer2 = new Peer({ wrtc: wrtc })

api

peer = new Peer([opts])

Create a new WebRTC peer connection.

A "data channel" for text/binary communication is always established, because it's cheap and often useful. For video/voice communication, pass the stream option.

If opts is specified, then the default options (shown below) will be overridden.

{
  initiator: false,
  channelConfig: {},
  channelName: '<random string>',
  config: { iceServers: [{ urls: 'stun:stun.l.google.com:19302' }, { urls: 'stun:global.stun.twilio.com:3478?transport=udp' }] },
  offerOptions: {},
  answerOptions: {},
  sdpTransform: function (sdp) { return sdp },
  stream: false,
  streams: [],
  trickle: true,
  allowHalfTrickle: false,
  wrtc: {}, // RTCPeerConnection/RTCSessionDescription/RTCIceCandidate
  objectMode: false
}

The options do the following:

  • initiator - set to true if this is the initiating peer

  • channelConfig - custom webrtc data channel configuration (used by createDataChannel)

  • channelName - custom webrtc data channel name

  • config - custom webrtc configuration (used by RTCPeerConnection constructor)

  • offerOptions - custom offer options (used by createOffer method)

  • answerOptions - custom answer options (used by createAnswer method)

  • sdpTransform - function to transform the generated SDP signaling data (for advanced users)

  • stream - if video/voice is desired, pass stream returned from getUserMedia

  • streams - an array of MediaStreams returned from getUserMedia

  • trickle - set to false to disable trickle ICE and get a single 'signal' event (slower)

  • wrtc - custom webrtc implementation, mainly useful in node to specify in the wrtc package. Contains an object with the properties:

  • objectMode - set to true to create the stream in Object Mode. In this mode, incoming string data is not automatically converted to Buffer objects.

peer.signal(data)

Call this method whenever the remote peer emits a peer.on('signal') event.

The data will encapsulate a webrtc offer, answer, or ice candidate. These messages help the peers to eventually establish a direct connection to each other. The contents of these strings are an implementation detail that can be ignored by the user of this module; simply pass the data from 'signal' events to the remote peer and call peer.signal(data) to get connected.

peer.send(data)

Send text/binary data to the remote peer. data can be any of several types: String, Buffer (see buffer), ArrayBufferView (Uint8Array, etc.), ArrayBuffer, or Blob (in browsers that support it).

Note: If this method is called before the peer.on('connect') event has fired, then an exception will be thrown. Use peer.write(data) (which is inherited from the node.js duplex stream interface) if you want this data to be buffered instead.

peer.addStream(stream)

Add a MediaStream to the connection.

peer.removeStream(stream)

Remove a MediaStream from the connection.

peer.addTrack(track, stream)

Add a MediaStreamTrack to the connection. Must also pass the MediaStream you want to attach it to.

peer.removeTrack(track, stream)

Remove a MediaStreamTrack from the connection. Must also pass the MediaStream that it was attached to.

peer.replaceTrack(oldTrack, newTrack, stream)

Replace a MediaStreamTrack with another track. Must also pass the MediaStream that the old track was attached to.

peer.addTransceiver(kind, init)

Add a RTCRtpTransceiver to the connection. Can be used to add transceivers before adding tracks. Automatically called as neccesary by addTrack.

peer.destroy([err])

Destroy and cleanup this peer connection.

If the optional err parameter is passed, then it will be emitted as an 'error' event on the stream.

Peer.WEBRTC_SUPPORT

Detect native WebRTC support in the javascript environment.

var Peer = require('simple-peer')

if (Peer.WEBRTC_SUPPORT) {
  // webrtc support!
} else {
  // fallback
}

duplex stream

Peer objects are instances of stream.Duplex. They behave very similarly to a net.Socket from the node core net module. The duplex stream reads/writes to the data channel.

var peer = new Peer(opts)
// ... signaling ...
peer.write(new Buffer('hey'))
peer.on('data', function (chunk) {
  console.log('got a chunk', chunk)
})

events

Peer objects are instance of EventEmitter. Take a look at the nodejs events documentation for more information.

Example of removing all registered close-event listeners:

peer.removeAllListeners('close')

peer.on('signal', data => {})

Fired when the peer wants to send signaling data to the remote peer.

It is the responsibility of the application developer (that's you!) to get this data to the other peer. This usually entails using a websocket signaling server. This data is an Object, so remember to call JSON.stringify(data) to serialize it first. Then, simply call peer.signal(data) on the remote peer.

(Be sure to listen to this event immediately to avoid missing it. For initiator: true peers, it fires right away. For initatior: false peers, it fires when the remote offer is received.)

peer.on('connect', () => {})

Fired when the peer connection and data channel are ready to use.

peer.on('data', data => {})

Received a message from the remote peer (via the data channel).

data will be either a String or a Buffer/Uint8Array (see buffer).

peer.on('stream', stream => {})

Received a remote video stream, which can be displayed in a video tag:

peer.on('stream', stream => {
  var video = document.querySelector('video')
  if ('srcObject' in video) {
    video.srcObject = stream
  } else {
    video.src = window.URL.createObjectURL(stream)
  }
  video.play()
})

peer.on('track', (track, stream) => {})

Received a remote audio/video track. Streams may contain multiple tracks.

peer.on('close', () => {})

Called when the peer connection has closed.

peer.on('error', (err) => {})

Fired when a fatal error occurs. Usually, this means bad signaling data was received from the remote peer.

err is an Error object.

error codes

Errors returned by the error event have an err.code property that will indicate the origin of the failure.

Possible error codes:

  • ERR_WEBRTC_SUPPORT
  • ERR_CREATE_OFFER
  • ERR_CREATE_ANSWER
  • ERR_SET_LOCAL_DESCRIPTION
  • ERR_SET_REMOTE_DESCRIPTION
  • ERR_ADD_ICE_CANDIDATE
  • ERR_ICE_CONNECTION_FAILURE
  • ERR_SIGNALING
  • ERR_DATA_CHANNEL
  • ERR_CONNECTION_FAILURE

connecting more than 2 peers?

The simplest way to do that is to create a full-mesh topology. That means that every peer opens a connection to every other peer. To illustrate:

full mesh topology

To broadcast a message, just iterate over all the peers and call peer.send.

So, say you have 3 peers. Then, when a peer wants to send some data it must send it 2 times, once to each of the other peers. So you're going to want to be a bit careful about the size of the data you send.

Full mesh topologies don't scale well when the number of peers is very large. The total number of edges in the network will be full mesh formula where n is the number of peers.

For clarity, here is the code to connect 3 peers together:

Peer 1

// These are peer1's connections to peer2 and peer3
var peer2 = new Peer({ initiator: true })
var peer3 = new Peer({ initiator: true })

peer2.on('signal', data => {
  // send this signaling data to peer2 somehow
})

peer2.on('connect', () => {
  peer2.send('hi peer2, this is peer1')
})

peer2.on('data', data => {
  console.log('got a message from peer2: ' + data)
})

peer3.on('signal', data => {
  // send this signaling data to peer3 somehow
})

peer3.on('connect', () => {
  peer3.send('hi peer3, this is peer1')
})

peer3.on('data', data => {
  console.log('got a message from peer3: ' + data)
})

Peer 2

// These are peer2's connections to peer1 and peer3
var peer1 = new Peer()
var peer3 = new Peer({ initiator: true })

peer1.on('signal', data => {
  // send this signaling data to peer1 somehow
})

peer1.on('connect', () => {
  peer1.send('hi peer1, this is peer2')
})

peer1.on('data', data => {
  console.log('got a message from peer1: ' + data)
})

peer3.on('signal', data => {
  // send this signaling data to peer3 somehow
})

peer3.on('connect', () => {
  peer3.send('hi peer3, this is peer2')
})

peer3.on('data', data => {
  console.log('got a message from peer3: ' + data)
})

Peer 3

// These are peer3's connections to peer1 and peer2
var peer1 = new Peer()
var peer2 = new Peer()

peer1.on('signal', data => {
  // send this signaling data to peer1 somehow
})

peer1.on('connect', () => {
  peer1.send('hi peer1, this is peer3')
})

peer1.on('data', data => {
  console.log('got a message from peer1: ' + data)
})

peer2.on('signal', data => {
  // send this signaling data to peer2 somehow
})

peer2.on('connect', () => {
  peer2.send('hi peer2, this is peer3')
})

peer2.on('data', data => {
  console.log('got a message from peer2: ' + data)
})

memory usage

If you call peer.send(buf), simple-peer is not keeping a reference to buf and sending the buffer at some later point in time. We immediately call channel.send() on the data channel. So it should be fine to mutate the buffer right afterward.

However, beware that peer.write(buf) (a writable stream method) does not have the same contract. It will potentially buffer the data and call channel.send() at a future point in time, so definitely don't assume it's safe to mutate the buffer.

connection does not work on some networks?

If a direct connection fails, in particular, because of NAT traversal and/or firewalls, WebRTC ICE uses an intermediary (relay) TURN server. In other words, ICE will first use STUN with UDP to directly connect peers and, if that fails, will fall back to a TURN relay server.

In order to use a TURN server, you must specify the config option to the Peer constructor. See the API docs above.

js-standard-style

Who is using simple-peer?

  • WebTorrent - Streaming torrent client in the browser

  • Virus Cafe - Make a friend in 2 minutes

  • Instant.io - Secure, anonymous, streaming file transfer

  • Zencastr - Easily record your remote podcast interviews in studio quality.

  • Friends - Peer-to-peer chat powered by the web

  • Socket.io-p2p - Official Socket.io P2P communication library

  • ScreenCat - Screen sharing + remote collaboration app

  • WebCat - P2P pipe across the web using Github private/public key for auth

  • RTCCat - WebRTC netcat

  • PeerNet - Peer-to-peer gossip network using randomized algorithms

  • PusherTC - Video chat with using Pusher. See guide.

  • lxjs-chat - Omegle-like video chat site

  • Whiteboard - P2P Whiteboard powered by WebRTC and WebTorrent

  • Peer Calls - WebRTC group video calling. Create a room. Share the link.

  • Netsix - Send videos to your friends using WebRTC so that they can watch them right away.

  • Stealthy - Stealthy is a decentralized, end-to-end encrypted, p2p chat application.

  • oorja.io - Effortless video-voice chat with realtime collaborative features. Extensible using react components 🙌

  • TalktoMe - Skype alternative for audio/video conferencing based on WebRTC, but without the loss of packets.

  • CDNBye - CDNBye implements WebRTC datachannel to scale live/vod video streaming by peer-to-peer network using bittorrent-like protocol

  • Detox - Overlay network for distributed anonymous P2P communications entirely in the browser

  • Metastream - Watch streaming media with friends.

  • firepeer - secure signalling and authentication using firebase realtime database

  • Genet - Fat-tree overlay to scale the number of concurrent WebRTC connections to a single source (paper).

  • WebRTC Connection Testing - Quickly test direct connectivity between all pairs of participants (demo).

  • Firstdate.co - Online video dating for actually meeting people and not just messaging them

  • TensorChat - It's simple - Create. Share. Chat.

  • On/Office - View your desktop in a WebVR-powered environment

  • Cyph - Cryptographically secure messaging and social networking service, providing an extreme level of privacy combined with best-in-class ease of use

  • Ciphora - A peer-to-peer end-to-end encrypted messaging chat app.

  • Whisthub - Online card game Color Whist with the possibility to start a video chat while playing.

  • Brie.fi/ng - Secure anonymous video chat

  • Peer.School - Simple virtual classroom starting from the 1st class including video chat and real time whiteboard

  • FileFire - Transfer large files and folders at high speed without size limits.

  • safeShare - Transfer files easily with text and voice communication.

  • CubeChat - Party in 3D 🎉

  • Homely School - A virtual schooling system

  • AnyDrop - Cross-platform AirDrop alternative with an Android app available at Google Play

  • Share-Anywhere - Cross-platform file transfer

  • QuaranTime.io - The Activity board-game in video!

  • Trango - Cross-platform calling and file sharing solution.

  • P2PT - Use WebTorrent trackers as signalling servers for making WebRTC connections

  • Dots - Online multiplayer Dots & Boxes game. Play Here!

  • simple-peer-files - A simple library to easily transfer files over WebRTC. Has a feature to resume file transfer after uploader interruption.

  • WebDrop.Space - Share files and messages across devices. Cross-platform, no installation alternative to AirDrop, Xender. Source Code

  • Speakrandom - Voice-chat social network using simple-peer to create audio conferences!

  • Deskreen - A desktop app that helps you to turn any device into a secondary screen for your computer. It uses simple-peer for sharing entire computer screen to any device with a web browser.

  • Your app here! - send a PR!

license

MIT. Copyright (c) Feross Aboukhadijeh.

NPM DownloadsLast 30 Days