libdatachannel VS µWebSockets

You can use https://github.com/paullouisageneau/libdatachannel for your C/C++ integration needs. It's 10k lines. So the answer is 0. Its required dependencies (I assume this as they are git submodules in deps) are more than 100k lines, though, srtp support making the bulk of it. On my machine it took 11 seconds to compile it.

Irssi is 64k lines (plus its dependencies), so I guess that makes WebRTC complicated.

Can't argue that DCC isn't simple, but perhaps the protocol deviced decades ago is a bit too simple.

Most of the work happened in the libdatachannel! You can check out my PR here[0]

[0] https://github.com/paullouisageneau/libdatachannel/commit/a6...

I am really excited about https://github.com/sepfy/libpeer. It has examples ready for ESP32 etc....

When working on KVS I wasn't familiar with the embedded space at all. I saw 'heavyweight' embedded where you were running on Linux. Then you had RTOS/No OS at all. I wasn't prepared for these devices at all. If we can make WebRTC work in the embedded space I think it will really accelerate what developers are able to build!

Remotely driven cars, security cameras, robots in hospitals that bring iPads to infectious patients etc... Creative people are building amazing things. The WebRTC/video space needs to work harder and support them :)

-----

I love how diverse the WebRTC space is now. Outside of this implementation you have plenty of other options!

* https://github.com/shinyoshiaki/werift-webrtc (Typescript)

* https://github.com/pion/webrtc (Golang)

* https://github.com/webrtc-rs/webrtc (Rust)

* https://github.com/algesten/str0m (Rust)

* hhttps://github.com/sepfy/libpeer (C/Embedded)

* https://webrtc.googlesource.com/src/ (C++)

* https://github.com/sipsorcery-org/sipsorcery (C#)

* https://github.com/paullouisageneau/libdatachannel (C++)

* https://github.com/elixir-webrtc (Elixir)

* https://github.com/aiortc/aiortc (Python)

* GStreamer’s webrtcbin (C)

See https://github.com/sipsorcery/webrtc-echoes for examples of some running against each other.

This is not true, there are actually multiple WebRTC implementations in different languages besides the reference library: aiortc (python), libdatachannel (C++), sipsorcery (C#),webrtc-rs (rust), werift (Typescript), and Amazon Kinesis (C)

Use any means necessary to transfer your data across devices. Could be IPFS, could be FTP, could be EventSource, WebSocket, WebTransport, Fetch, whatever. See https://github.com/guest271314/secure-file-transfer; offscreen-webrtc, https://github.com/paullouisageneau/libdatachannel.

I've successfully used libdatachannel to Web pages to connect native applications and stream data to the browser.

Alternatively you can use your server as a signaling server for WebRTC (Insertable Streams ("Breakout Box"), or data channels https://github.com/paullouisageneau/libdatachannel), then users (peers) can exchange data themselves and you don't need to store anything, see True End-to-End Encryption with WebRTC Insertable Streams, A complete example for a WebRTC datachannel with manual signaling.

there is also a c++ library that can be used to open a data channel connection, I think a number of SFU “servers?” use this library (I wish I had) https://libdatachannel.org/

They use (uWebSockets)[https://github.com/uNetworking/uWebSockets], which was written in C++, but has an interface to use in NodeJS. It's been really performant for me in my simple tests compared to other popular websocket libs that slow down fairly quickly.

µWebSockets, pronounced as "microWebSocket”, is a WebSocket library written in C++ and has Node.js bindings. Its design focuses on being efficient and scalable, making it ideal for applications that require high concurrency and low latency.

You can do that with any single threaded library that leaves threading to you. Like for example https://github.com/uNetworking/uWebSockets

Websockets are also pretty valuable for updating the page in real time, there are servers in many languages. I'm a big fan of https://github.com/uNetworking/uWebSockets which is C++ but also has JS bindings to use with Node.js.

Can you include uWebsockets? https://github.com/uNetworking/uWebSockets

μWebSockets Génial, rapide, peut transformer l’eau en vin. Nécessite C++17.

Not exaclty -- it looks like it's pretty overkill for my needs

I'm looking for something more like websocketpp[0], or even just grpc without a requisite proxy. uWebsockets looks really promising, being header only, but in the fine print requires a runtime library. unfortunately, none of that ecosystem seems to use cmake, making integrating it that much more of a pain.

why use cpp for this, I'm sure some HNer will ask. the ray tracer itself is using cuda, that's why. I've also debated

- running it as a grpc server and having some proxy in a more web-accessible language

- creating python bindings and using python to make a websocket/http server for it

neither of those are out of the question, but they're not my first choices, because I'd like to keep the build & execution simple. introducing dependencies, especially other executables, is in conflict with that.

i don't need anything particularly scalable -- a threaded implementation, or one using select() would be fine, if not preferable.

[0] https://docs.websocketpp.org/

[1] https://github.com/uNetworking/uWebSockets

Really cool i also made and CAPI for using WebSocket in C, https://github.com/uNetworking/uWebSockets/tree/master/capi

I will take a deep look on your project thanks for sharing!

We discover a really fast, small, and well maintained C++ Library called uNetworking/uWebSockets, but no C API available, so we create and adapt the full C API from uNetworking/uWebSockets and will integrate libuv powered fetch and file IO, this same C API is used by Bun