ws

Interesting that https://github.com/uNetworking/uWebSockets.js (which is C++ with node bindings) outperforms the raw C++ uWebSockets implementation. It's also interesting that https://github.com/websockets/ws does not appear in this study, given that in the node ecosystem it is ~3x more likely to be used (not a perfect measurement but ws has 28k github stars vs uWebSockets 8k stars)

Sure thing. The video and voice chat is powered by WebRTC. The getUserMedia API allows a browser to access the webcam and microphone of the device. I used my own simple-peer (https://github.com/feross/simple-peer) library to make WebRTC a bit easier to work with. The server is Node.js. I'm using Next.js for the first time on this project. I usually use a custom Express server for my projects. I'm a fan of several of Next.js's decisions -- it feels really nice to use, if a bit limiting sometimes. I use the 'ws' package (https://github.com/websockets/ws) to implement a WebSocket server which is used to help the peers get connected over WebRTC. Once peers are connected, all video and video is transferred directly in a peer-to-peer fashion. Except sometimes the connection can't be established, so to improve reliability of WebRTC you need to s

Thanks. Does bufferedAmount work better than it does on WebSockets[0], because I haven't had much luck with that. [0]: https://github.com/websockets/ws/issues/492

> If it supports WebSocket, it should be relatively easy to layer Cap'n Proto RPC on top of that. How would the new streaming functionality be implemented over WebSockets? WS has no flow control. You can check bufferedAmount but I found it to be fairly useless[0]. Maybe it's improved in the last 1.5 years or I was using it wrong. > HTTP is fundamentally a one-way, FIFO request-response protocol, whereas Cap'n Proto is multi-directional and asynchronous. Starting a separate HTTP connection for each call -- with connections initiated in both directions -- would be pretty ugly and have lots of issues with synchronization and routing. I think you could get a long way using HTTP/2 and server-sent events. [0]: https://github.com/websockets/ws/issues/492 EDIT: added link to bufferedAmount issue

Following are the alternatives :- Action text in RoR <=> DraftJS (Isomorphic ReactJS plugin with server side rendering), Froala (compatible with most of SPA frameworks) Active Record in RoR <=> SequelizeJS (ORM), Slonik(Non-ORM, my recommendation) in NodeJS Action Cable in RoR <=> WS, Socket.io 2.0 (recommended) DraftJS - https://github.com/facebook/draft-js Froala - https://www.froala.com/wysiwyg-editor SequelizeJS - https://sequelize.org/master/ Slonik - https://github.com/gajus/slonik WS - https://github.com/websockets/ws Socket.io - https://socket.io/

Which must be doubly frustrating since they have a copy of https://github.com/websockets/ws in the node_modules folder, and that has the appropriate license text (MIT in that case)

Did you ever try to disable permessage-deflate with ws? It will never be as lightweight as uws because ws is built on top of `net.Socket` but I think you hit this ws issue https://github.com/websockets/ws/issues/804 in the WebTorrent tracker. I think ws will use 3/4 times more memory than uws with permessage-deflate disabled which is a lot, but far different from 47 times as advertised.

This looks interesting. I'm surprised there aren't many existing native HTTP modules for NodeJS. Found websockets/was as an alternative https://github.com/websockets/ws It would be a fun experiment to implement a native HTTP module in Rust using Neon. https://github.com/neon-bindings/neon

If possible, consider leaving socket.io. If you can, check out https://github.com/websockets/ws .

I use [ws](https://github.com/websockets/ws). I've never had any trouble with it, and it benchmarks well. Of course, there's no fallback there; just websockets. I haven't seen a websocket+fallback lib that seems like it will work well. Requiring sticky sessions and disallowing using node's cluster module is the norm, and neither of those are appealing. We've rolled our own polling fallback, which is also used to cleanly handle missed messages during a websocket reconnect.

SockJS is definitely a reasonable choice as a base. At Pusher we use a fork of SockJS for HTTP fallback but we actually use em-websocket [1] (ruby) for our WebSocket API. Given the opportunity we'd probably move away from SockJS to something much simpler because we only want the HTTP fallback part and it only handles < 8% of our connections. If you _only_ want WebSocket connections with no HTTP fallback then Faye WebSocket [2] may be an option. But any production application is going to require fallback for older browsers and pesky proxies/firewalls. Faye [3] is solid (obviously used Faye WebSocket), has implementations in Node and Ruby, but is a PubSub solution. I'd kinda argue that any real-time app needs at least PubSub functionality anyway. The ws Node module [4] is apparently "The fastest RFC-6455 WebSocket implementation for Node.js

We use ws(https://github.com/websockets/ws) in prod. Clean, fast, and simple. Plus it supports browsify using native implementation but wraps it to fit the server side api.