
Rtc.io – Open source WebRTC library - gioi
http://rtc.io/
======
kodablah
Does this have a WebRTC data channel client implementation, or does it solve
more rudimentary aspects of WebRTC such as passing offers and answers (i.e.
signalling)? This node module [1] is a client for data channels (but sadly no
native Windows support yet which is a needed thing [2]). Once more widely
adopted, WebRTC will be a great data communication method between users of all
sorts of common-user desktop applications, not just browsers, mainly because
of it's NAT traversal techniques and encrypted-by-default requirement. In some
instances a TURN proxy may be required (and the popular one [3] isn't the
easiest to setup, and doesn't have a native-Windows-not-Cygwin install). This
is especially true for users behind large corporate/government networks that
don't give you a single public IP per machine.

I have done a lot of work w/ WebRTC data channels recently and I am working on
a POC for hosting one's own "page" (i.e. facebook-esque profile page)
themselves. WebRTC I think is the best technology so far for the
decentralization of internet data from hosted servers to users. It still
requires some server side things such as signalling (the handshake), STUN
servers (external IP discovery behind a network), and TURN servers (proxies
for complicated networks). By packaging up those three things into a single
server that can be easily deployed by someone you trust (i.e. some kind of
regional "manager" of sorts) and having good software to display web content
over WebRTC data channels, a neighborhood-level darknet of sorts will be very
feasible for even non-technical users.

1 - [https://github.com/js-platform/node-webrtc](https://github.com/js-
platform/node-webrtc) 2 - [https://github.com/js-platform/node-
webrtc/issues/42](https://github.com/js-platform/node-webrtc/issues/42) 3 -
[http://code.google.com/p/rfc5766-turn-
server/](http://code.google.com/p/rfc5766-turn-server/)

~~~
djoehlman
The client portions are definitely in the library, and as you point out the
node-webrtc library is looking really promising for interop with server
processes.

If you need any help with the POC that you are currently working on feel free
to reach out and I'll see what I can do (I'm the main dev working on rtc.io at
the moment). Also, the primary dev on the node-webrtc project (modeswitch) is
super helpful so I'm sure he'd be happy to help out also.

Either twitter or github is a good way to get in touch with me - usename is
DamonOehlman in both channels...

------
erichocean
Dear GitHub: Please make it possible to "follow", or at the very least, star
an Organization. I want to bookmark [https://github.com/rtc-
io](https://github.com/rtc-io), not a particular project they are doing.

Organizations, as currently implemented, are the opposite of "social". Spend
some of that $100 million and fix it please. Thanks.

------
ricardobeat
Worth mentioning an even simpler library for newcomers:
[http://simplewebrtc.com/](http://simplewebrtc.com/)

~~~
Sir_Cmpwn
Worth mentioning that you probably don't even need a library. The WebRTC API
is not obtuse.

~~~
djoehlman
I agree with that comment, which was one of the reasons rtc.io was created in
the first place. A lot of the other libraries hide away the core browser
objects through higher-level JS objects, whereas the core rtc.io library (rtc
- [https://github.com/rtc-io/rtc](https://github.com/rtc-io/rtc)) encourages
direct use of the browser api.

Some of the other modules (rtc-quickconnect, rtc-glue, etc) in the rtc.io
suite, however, do take you further away from the metal but if you are
comfortable with the core browser APIs then using a combination of rtc-
signaller and the connection coupling helper in rtc ([https://github.com/rtc-
io/rtc/blob/master/couple.js](https://github.com/rtc-
io/rtc/blob/master/couple.js)) will probably give the most flexible option for
writing a WebRTC application.

Just be aware that there are some bizarre edge cases when working with WebRTC
that can leave you scratching your head at times. The rtc/couple module takes
care of some, but there are still others that I'm still investigating
solutions for, e.g. [https://github.com/rtc-
io/rtc/issues/14](https://github.com/rtc-io/rtc/issues/14)

------
smaddock
[http://peerjs.com/](http://peerjs.com/) is the best library I've found for
WebRTC thus far. Their documentation is fair, there's decent support for
DataChannels and they've also open sourced a signalling server.
[https://github.com/peers/peerjs-server](https://github.com/peers/peerjs-
server)

~~~
silviapfeiffer
Just to be complete: rtc.io has a signalling server at
[https://github.com/rtc-io/rtc-switchboard](https://github.com/rtc-io/rtc-
switchboard) . Choice of library is up to you. :-)

~~~
djoehlman
It does work best with the signaller from the rtc.io suite:

[https://github.com/rtc-io/rtc-signaller](https://github.com/rtc-io/rtc-
signaller)

That said, it wouldn't take much to write an signalling client that followed
the basics of the messaging format if you did want to roll your own:

[https://github.com/rtc-io/rtc-signaller#signaller-message-
ha...](https://github.com/rtc-io/rtc-signaller#signaller-message-handlers)

------
motyar
Is there any app or project something like btysnc? I mean data sync using
WebRTC? Any thought about speed? Can it be faster than btysnc? Thanks

~~~
djoehlman
I think there has been some progress made on implementing BitTorrent like
clients using WebRTC data channels:

[https://github.com/feross/webtorrent](https://github.com/feross/webtorrent)

I haven't done that much investigation myself yet, but I definitely think it's
possible. No idea on which will be faster, I imagine it will come down to
quantity and quality of peers in both cases...

------
Thiz
I am new to WebRTC so here is my question: how can you "ring" my browser so I
know I have an incoming call without you first telling me to go to a specific
url?

I believe WebRTC has great potential to replace facetime and skype with a
browser based version.

~~~
0x0
I've just started looking into it, and as far as I can understand, you can't
"push" a call to others. You will have to supply a web page and the javascript
to connect to a "meeting room" or whatever (using ajax?) to "find" the other
peer, and exchange connection parameters, before the webRTC stuff kicks in.
(Correct me if I'm wrong)

~~~
pfraze
Yeah, the "signalling" process is implemented by applications, and needs
either a WebSocket or SSE stream.

~~~
Thiz
So we could use a browser extension to listen in the background to a central
phone server for incoming calls while we happily surf the web and then get the
"ring" opening the url in a tab for the incoming call to take place?

Interesting...

~~~
arcameron
Yeah, but why would you want to take calls in your browser? Why not a separate
application (node-webkit, Firefox app) that runs as its own process a la Skype
clone?

------
vectorpush
Does anyone know of any resources (maybe a code example) for establishing a
webrtc peer connection between a browser and an arbitrary service?

~~~
silviapfeiffer
What does the "arbitrary service" provide? Is it a video conference, audio
conference, or data channel end point?

~~~
vectorpush
Data channels are what I have in mind, but I can't seem to find any webrtc
code that connects a browser to anything other than another browser.

~~~
djoehlman
Thanks to a project that has been previously pointed out (node WebRTC bindings
- [https://github.com/js-platform/node-webrtc](https://github.com/js-
platform/node-webrtc)) interop between a browser and node applications isn't
too far away.

There is this issue which is being worked on at the moment in the node-webrtc
library:

[https://github.com/js-platform/node-webrtc](https://github.com/js-
platform/node-webrtc)

Once that's resolved data channel connectivity between a browser and command-
line app, server, etc should be reasonably simple. While this bug is
outstanding, it is possible to fall back to Rtp data channels in the browser
and if that is something that is of interest then we can look at putting
together some examples with rtc.io if that would help you out.

------
alecsmart1
This is definitely a good and much required resource. You should look at also
adding components for iOS and Android as well.

~~~
badfilesam
Do you know if it could actually work on iOS and Android? It doesn't seem
supported by Safari yet [1]. I'm deeply interested by capturing the microphone
on mobile devices with WebRTC.

[1] [http://iswebrtcreadyyet.com](http://iswebrtcreadyyet.com)

~~~
alecsmart1
Safari doesn't support it. But native apps can support it. I believe Chrome
for mobile also supports it.

~~~
davidcann
Chrome on iOS does not. Chrome on some Android devices does.

