manifesto VS FirebaseRTC

The toll of feature creep is what led to the informal adoption of The Extensible Web Manifesto, which argues that the web platform should focus on minimalism and performance. New features should be addressed via extensibility whenever possible. Things like WASM, Houdini, and web components were all prioritized to allow implementation of features on top of the platform and thus reduce the rate at which browsers accumulate technical debt. Features being proposed face an uphill battle if they can be implemented using a more generic mechanism, if there are already competitive alternatives, or if the proposed platform extension is not minimal.

The noise floor in the standards process is deafeningly high because there are always some passionate advocates of a technology or feature arguing for its inclusion. A bunch of prominent web platform folks published The Extensible Web Manifesto ~10 years ago arguing for browser vendors to focus on minimalism and performance while addressing new needs via extensibility.

> I just wish WebRTC wasn't so prescriptive of DTLS/SRTP.

There was a webrtc-webtransport spec, but it got renamed to p2p-webtransport[1]. I'm not sure when the rename happened. Feels like a pretty strong indicator of webrtc being deconstructed, but whose to say this goes anywhere. We'd also need webcodecs.

It's somewhat scary & also somewhat exciting thinking of the one good, working, browser supported standard being ripped into pieces (p2p-webtransport, webcodecs, more) & being user-implemented. Having the browser & servers have a well-known target is both great but also perhaps confining. If we leave it up to each site/library to DIY their solution, figure out how to balance the p2p feeds, it'll be a long long time before the Rest of the World (other than the very big few) have reasonable tech again. WebRTC is quite capable & a nice even playing field, with lots of well-known rules to enable creative interopation. We'd be throwing away a lot. I'd hoped for webrtc-webtransport, to at least keep some order & regularity, but that seems out, at the moment. But Webrtc-nv is still ultra-formative; anything could happen.

The rest of the transport stack is also undergoing massive seismic shifts. I feel like we're in for a lot of years of running QUIC or HTTP3 over WebRTC Data-Channels and over WebTransport, so we can explore solutions the new capabilities while not having to ram each & every change through with the browser implementers. It feels like a less visible but far more massive Web Extensibility Manifesto moment, only at sub-HTML levels[2]. The browsers refused to let us play with HTTP Push, never let appdevs know realtime resources had been pushed at the browser, so we're still debating terrible WebSocket vs SSE choices; terrible. I think of gRPC-web & what an abomination that is, how sad & pointless that effort is; all because the browser is a mere glimmer of the underlying transport. I feel like a lot of experimentation & exploration is going to happen if we start exploring QUIC or HTTP3 over WebTransport. Attempts to reimagine alternatives to WebRTC are also possible if we had specs like p2p-webtransport, or just did QUIC over DataChannels. Running modern protocols in the client, not the browser, seems like a semi-cursed future, but necessary, at least for a while, while we don't yet know what we could do. The browsers are super laggy, slow to expose capabilities.

[1] https://github.com/w3c/p2p-webtransport

[2] https://github.com/extensibleweb/manifesto

I can't help but feel like this is the worst. Every time we step away from HTML & the DOM & into a further farther reach of abstraction, into something custom crafted & artisinal, we lose our valuable common heritage. We flea from common understandability & recurse into something ever more unique & virtual.

In the process- as is the case with Google Docs[1]- we lose things like the ability for web extensions to work, if this is a web hosted vscode instance (vscode server, openvscode, code-server, others). Running a debugger against this part of vscode- web or native- now yields only garbage junk information.

Right now this is just the terminal. I think- "it could be worse". But it chills me deeply that the terminal is now no longer real information. It's now just a happenstance jumble of pixels, powered by only it's own inner logic & a unique maze of libraries. Big tech keeps optimizing and optimizing, & the motive we keep being sold- this is for your good, this helps you- is one I frankly have a very hard time negotiating with myself. De-webbifying the web, de-commonizing the common platform- as Facebook has done by virtualizing the DOM- feels like this ever-running big-bang from a truthful original universe into a sparse, cold, expanding universe where each little fragment defines itself, where the common hypertext medium no longer means anything.

I keep waiting for some moments of contraction, some coming back together, for things to make more sense again, to recontract into something more solid. React's first WebComponents PR[2] is a notable re-contracting, re-platforming- a powerful act I frankly didn't expect, so rare as to feel practically unprecedented.

I realize much of this flexibility, the demonstrated versatility of the web & usage of the various pieces of it represents much of it's strength. The platform being a low-level platform where higher level platforms can be created is amazing; the Extensible Web Manifesto[3] speaks to that emergence of newer higher levels systems. And right now we're in early days, just starting a precambrian explosion of higher level web, as technology like WebAssembly only just begins to become real- still so early, still way pre-pre- Interface Types[4]/Host Bindings, only just the crudest emulation beginning in via projects like Rust's wasm-bindgen / web-sys. I am happy we are still exploding. We have so much more to exlpore. But gee I also question so much when big enterprises turn hypertext into pixels. To move compute into webassembly is a bold leap but the hypertext can survive, the DOM is still truth. It's so uncertain to me, feels like so much might be lost when giants like Microsoft or Google yank out the HTML & replace it with pixels, pushed into our faces. It feels like betrayal, like sabotage, like we're giving up truth.

[1] https://workspaceupdates.googleblog.com/2021/05/Google-Docs-...

[2] https://github.com/facebook/react/pull/22184 https://news.ycombinator.com/item?id=29505332 (16 days, 0 comments)

[3] https://github.com/extensibleweb/manifesto

[] https://github.com/WebAssembly/interface-types/blob/main/pro...

The main problem isn't CPU and GPU performance, those problems had (to some extent) already been solved with asm.js and WebGL, at least for some types of games. It's all the other APIs and the general "feature churn" in browsers which are problematic for games.

Some examples:

- The fullscreen and pointerlock APIs show popup warnings which behave entirely differently between browsers.

- Timer precision has been reduced to around 1ms post-Spectre/Meltdown, and jittered on top. This makes it very hard to avoid microstuttering (we don't even need a high-precision timer, just a way to query the display refresh rate... but guess what, there is no way to query the display refresh rate)

- WebAudio is ... I don't even know what... all we need is simple buffer streaming, and the only two ways to do this in WebAudio are either deprecated (ScriptProcessorNode) or not usable without proper threading (audio worklets), and guess what, threading is also disabled or behind HTTP response headers post-Spectre.

- Games need UDP style non-guaranteed networking, but we only get this as a tiny part of WebRTC (DataChannels).

...and the list goes on. In theory there are web APIs useful for gaming, but in practice those APIs have been designed for entirely different use cases, and they are not flexible enough to be reassigned to different use cases (like games). The web needs a "game mode", or better a "DirectX initiative", a set of low level APIs and features similar to WASM and WebGL/WebGPU, and if not designed specifically for games, than at least low-level and generic enough to be useful for games.

This isn't a new idea, see the Extensible Web Manifesto:

https://extensiblewebmanifesto.org/

(backup: https://github.com/extensibleweb/manifesto)

But the ideas presented there didn't seem to have much of an impact with the web people (with the notable exception of WebGPU).

WebRTC it is: https://webrtc.org/

Yes only the network layer encryption. No file encryption as it will cost client browsers a lot in case of encrypting and then decrypting that at other end.

I have written more about it here: https://dikshantraj2001.medium.com/nat-stun-turn-and-ice-466...

Currently, I am using the public STUN servers only. If the IPs are not reachable, it would show an error and won't work as setting up TURN server would mean same as a third party server saving in file and serving it over network

You might also consider assessing complementary or alternative technologies; WebSocket and HTTP aren’t the only options when it comes to real-time communication, after all. WebRTC is similar to WebSocket, with the key difference being that it’s used to implement peer-to-peer connections without relying on a server. That can be especially helpful for video calls, allowing participants to communicate directly without introducing load to your server.

We use WebRTC to gain access to a user’s camera and microphone using the getUserMedia method. Typically, I would gain access to both of these from the same call. However, our experience requires the camera to flip from facing the environment to facing the user and I noticed that the small period of time the flip occurred (and microphone wasn’t available) contributed to a bit of audio lagging in the final recorded video. This was one of the nastier bugs I faced in development. So, we’ll just access each of these on their own media streams so that the camera can flip independently from the microphone.

Low latency streaming (<500ms): The Video SDK's infrastructure is built with WebbRTC, which helps to deliver secure and ultra-low latency video streams to all audiences at different bandwidths.

Web Real-Time Communication (WebRTC) is a technology developed by Google in 2013 for peer-to-peer communication. WebRTC enables web browsers to capture audio, video, exchange data, and teleconferencing without plugins or intermediaries. WebRTC achieve these through APIs and protocols that interact with one another. WebRTC media streaming when used with SocKet.IO will produce an application that streams media and exchange data instantly. Socket.IO is a library that provides low latency bi-directional communication between client and server. Socket.IO was built on websocket, a communication protocol that provides a full-duplex and low latency communication between server and browser. In this article, readers will learn how to build a video chat application using WebRTC and Socket.IO. This article is for web developers who wish to develop web applications that can stream media between two peers of computers in real-time without installing any plugins.

Possibly you what to look into WebRTC: https://webrtc.org/

Use the language you're comfortable with. Sounds like you're interested in creating a blockchain game. Writing your own simple game engine isn't simple. I would recommend utilizing an existing one for whatever language you want. If you still choose to write your own it can be a valuable lesson in graphical programming which I personally find fun. It's easier to cheat a webpage embedded game written in Javascript than one ported to WebASM in my experience and I've heard good things about WebRTC for embedded multiplayer games.

Have you looked into WebRTC? https://webrtc.org Seems like it supports exactly what you're looking for. SignalR is more for real-time messages, not really for streaming.

P2P is nothing new. It is a long-established means of connecting two or more people directly over a network. Web browsers are very capable of a wide range of P2P connections. Many apps use WebRTC to enhance realtime apps, but it is still an underutilized technology. Even with WebRTC, many apps are designed around the dependence on a central app server with WebRTC performing a user experience enhancement. Web meshes turn this idea on its head: Instead of using P2P connections to enhance the user experience, what if P2P connections were the foundation of the user experience? In other words, what if there was no central server?