Hacker News Reader

Comment by peutetre | Hacker News Reader

Better to focus on WebAssembly instead. Bring every language to the web.

JavaScript for some scripting, any other language for bigger applications.

Did they solve GC and DOM access ? It's been years since it was "just about to happen" and I stopped paying attention in the meantime. But if it had that I agree - it would be ideal if JS was a legacy thing and a saner WASM first class language got to replace it.

Keep the single threaded event loop approach but kill the JS semantics.

Garbage collection is solved to the extent that host garbage collection is now available via WasmGC:

https://developer.chrome.com/blog/wasmgc/

https://v8.dev/blog/wasm-gc-porting

But languages like C# want more features in WasmGC:

https://github.com/dotnet/runtime/issues/94420

No direct DOM access yet. You still have to use JavaScript glue code to get at the DOM.

The problem is that they promised that the WasmGC would include the much desired access to JavaScript objects but now this crucial aspect is no longer part of it and postponed again.

Actually I don't want DOM access and GC for wasm. At least not yet. It overcomplicates a lot and I simply cannot imagine that a GC can be one-size-fits-all languages.

I want fixed-size buffer-backed structs for JS. Basically a DataView as a C struct. This would massively benefit interop and solve some shortcomings of DataView.

There was a proposal for a binary AST for JS several years ago [1]. Why not just use that as JS0? It's separate and can offer new possibilities as well.

[1]: https://github.com/tc39/proposal-binary-ast

Problem with AST is that it still kind of forces JS semantics which we should be working away from if we're doing this big leap.

(I was the tech lead for this proposal)

How would this be useful for a JS0?

Wasm GC is shipped in stable releases of all major browsers except for Safari but that will be changing shortly if it hasn't already (my info is a few weeks old.) The important thing to note about Wasm is that all important functionality, such as access to I/O and the DOM, have to arrive in the form of host imports to a Wasm module. With this in mind, thanks to Wasm GC it is possible to do web UIs from Wasm by importing the relevant bits of the DOM API that the module needs. Projects like Hoot (Scheme) and Kotlin port are already demoing such things.

> Projects like Hoot (Scheme) and Kotlin port are already demoing such things.

And Scala.js has shipped it. [1] Although technically experimental, it has no known bugs and it has full support of things like manipulating DOM objects from Scala.js-on-Wasm code.

[1] https://www.scala-js.org/news/2024/09/28/announcing-scalajs-...

I thought the js DOM API was atrocious. But they copied it over with Java object hierarchy into Scala.js. Makes me want to give up on coding altogether.

good point. in a sense webassembly is that minimal very performant language. let javascript and typescript compile to webassembly, and you essentially got what is being proposed here

WebAssembly could replace JavaScript, the assembly language, once it has reached feature parity.

But there's still far to go. Large parts of the browser API are still not directly available in WASM.

I very much look forward to WASM reaching stability. It's very enjoyable to run Rust code in the browser.

right, making those APIs accessible from WASM is something i am also waiting for.

So you want more rights for code that’s harder to read than obfuscated JS?

What parts are not available?

WebAssembly can call arbitrary JavaScript through imports. You could literally provide an `eval` function if you were motivated to.

direct access to the DOM for example without having to go through the javascript host, which is slow and makes DOM intensive applications impractical

Or you can just draw to canvas to make the UI fast which is what Flutter does now:

https://flutterweb-wasm.web.app/

https://www.youtube.com/watch?v=Nkjc9r0WDNo

Drawing to canvas means recreating the UI and all its wide-sweeping concerns, which is quite an undertaking. And even if it were accomplished in a central open source library like Flutter, that adds a considerable amount to the package size of any application. Acceptable (or even preferred) for certain applications but not for most.

Providing access to an already proven DOM would be the better solution.

What would access to the DOM look like? WASM already has import and export (nearly) arbitrary functions. People keep saying it can't manipulate the DOM, but it clearly can. So, what's missing?

What is missing is that I never want to touch js for anything, so how do I do that if I have to write glue and imports in js/ts?

I thing we agree. JavaScript is awful, and TypeScript is simultaneously impressive and still awful. I think we have three options:

A) Get your hands dirty and write what you want. Once.

B) Chant along with the mob who doesn't even understand what they're asking for.

C) Wait several years for some super complicated solution to be designed by committee.

I wouldn't even want direct access to the DOM if we had it today. The DOM as an API is atrocious.

Instead, I want a set of nice functions that do things like put a graphical chart on the page - all in one call. Or one call to pass a bunch of 3D triangles or splats to visualize in a WebGL canvas. Or one call to play some audio samples. Or a function to poll for recording audio. And so on...

I choose option A.

there is also option D.

wait for a framework that implements option A.

if option A works, why aren't there any frameworks yet that implement it?

maybe all the framework devs are waiting for C?

but why?

you could be right about A but at present the majority view seems to be that C is the right option. which is what pushes me into going with B because i have no interest in developing my own framework.

if a framework appears that implements option A i'll gladly consider it. (just as long as it isn't tightly coupled with a backend)

> And even if it were accomplished in a central open source library like Flutter, that adds a considerable amount to the package size of any application.

The download isn't much different to a typical website. That Flutter demo in wasm is 2 megabytes.

Avalonia UI's WebAssembly uses canvas in C#: https://avaloniaui.net/

Uno Platform's WebAssembly implementation uses the DOM rather than drawing to canvas: https://platform.uno/

Uno's philosophy is to use platform native controls. The benefit is that you get platform native characteristics, the cost is it will never be exactly the same in each browser and platform.

You're joking, right? A 2mb bundle is *absolutely unacceptable*. People complain about React which is less than 100kb minified and gzipped. This website doesn't even include any images or anything...

It's clearly not. Real world applications exist today. Here's one:

https://earth.google.com/

2mb for Google Earth might be fine, but Google Earth is not your typical web app.

A 2mb base floor before any code or assets is not acceptable for most use cases.

So throwing out literally 99% of what makes the web actually portable and useful?

A random drawn rectangle is not a UI, it’s not accessible, not inspectable, not part of the de facto OS native toolkit.

If all we wanted is a random cross-platform canvas element to draw onto from a vm, it could be solved in a weekend. There are million examples of that.

> A random drawn rectangle is not a UI

Of course it is. All screen based user interfaces are blinking lights.

> it’s not accessible

It's best to read the documentation first. It's a low effort thing to do:

https://docs.flutter.dev/ui/accessibility-and-internationali...

Its web targeted version is still not accessible, even though they promised that they will actually render to HTML elements as much as possible. A single canvas element is not that.

If you're not going to read the documentation, read a blog post:

https://medium.com/flutter/accessibility-in-flutter-on-the-w...

From your own article:

> The Flutter team would like to eventually turn the semantics on by default in Flutter Web. However, at the moment, this would lead to noticeable performance costs in a significant number of cases, and requires some optimization before the default can be changed

Ah, so you admit it does indeed include accessibility but now what you're complaining about is performance. Not that you've actually tried it of course.

But good. That's a kind of progress.

Can you give an example of anything anywhere that manipulates the DOM without using JavaScript? Because it seems to me that pretty much every web application is currently using the javascript host, and the well written ones are pretty snappy.

this is going beyond my level of experience, but i thought there can't be any such example because javascript is the only way. the difference is between code written in javascript which is fast of course and accessing js functions from WASM, which is slower. how much slower, i don't know. i also don't know how old that discussion is where i learned about this. so maybe it improved since. that would be good news.

did you mean there are snappy webapplications running in WASM? if you have any examples, i'd be curiuos to learn more.

Previously you said:

> [...] go through the javascript host, which is slow

And now you admit:

> this is going beyond my level of experience [...]

> how much slower, i don't know

I guess people just repeat what they hear without questioning or understanding it, and then it becomes dogma.

> did you mean there are snappy webapplications running in WASM?

No. I meant that all existing web apps go through the "javascript host", using JavaScript. So if any of them are fast enough, and some certainly are, the problem isn't the "javascript host".

you are not answering my question. most existing webapps are not running inside WASM.

i am only talking about webapps running inside WASM. are there any WASM based webapps that are as fast as pure js webapps?

> you are not answering my question

Lol, your question asked me what I meant. I told you what I meant.

> are there any WASM based webapps that are as fast as pure js webapps?

You can browse links from Google for examples and benchmarks. Maybe one of these will scratch your itch, but I won't vouch for any of them:

https://madewithwebassembly.com/

But really, JavaScript and WebAssembly are both very fast. I don't think speed is the reason to choose one or the other.

For me, I like WebAssembly because it lets me program in languages other than JavaScript. JavaScript makes me want to scratch my eyes out.

> i thought there can't be any such example because javascript is the only way. the difference is between code written in javascript which is fast of course and accessing js functions from WASM

That doesn't have to be true.

Eventually WASM will get direct access to the full browser API, without going through JavaScript.

The browser exposes a browser API to the JavaScript VM it hosts, so things like the DOM are available.

Those things aren't available in other JavaScript VMs, like Node. (There's no DOM to interact with.)

And they're not yet available in the WASM VM in the browser, either.

The reason is that the WASM APIs/ABIs have not stabilised. It takes time to make right, but there is progress.

That doesn't have to be true.

Eventually WASM will get direct access to the full browser API, without going through JavaScript.

well, that is what i am waiting for. my point is that it's not the case yet, while the gp seemed to suggest that it's not needed because access through the host is available

A fundamental aspect of the Wasm capability security model is that all access to the outside world (I/O) is controlled via imports. Direct access to the entire browser API doesn't make sense in this context.

All imports have to come from the host, which in the case of the web means they have to be expressed as JavaScript. Behind the scenes they could be optimized, though, and I've heard that JS/Wasm engines maybe already be doing this with well-known imports (think Math.sin).

The DOM itself is very slow, much slower than Javascript, so you're not going to be seeing any great performance increase if WASM can access the DOM directly.

I also have to wonder if people are excited about replacing Javascript, why they would want to have HTML/CSS/DOM on top of WASM. A different front-end UI tech could be much better than slow, old DOM.

I commented this elsewhere, but the funny thing is that asm.js was the precursor to WebAssembly, and this proposal is essentially asking for asm.js back again.

Yes and no, there is a significant bundle size problem with wasm which is hard to fix.

I'd rather we just move to native cross platform applications and stop using a document browser to build interactive applications.

What's more likely is that all of this will probably be eclipsed by LLM and virtual assistants - which could be controlled by native apps with a dynamically generated GUI or voice.

I think APIs exposing data and executing functions will fundamentally change what we think the web is.

> I'd rather we just move to native cross platform applications and stop using a document browser to build interactive applications

Here you go. Do both native and wasm:

https://avaloniaui.net/

https://platform.uno/

https://flutter.dev/

Flutter example:

https://flutterweb-wasm.web.app/

Not that please. The flutter example took 20 seconds to load and the scroll is super choppy.

It’s unfortunate there isn’t a more native “app like” UI toolkit. Especially on mobile, web apps generally are bad and a lot of the reason is trying to shoehorn an app experience onto the dom.

It loads fast for me in Firefox, MS Edge, and Chrome. It's a 2 megabyte transfer and runs quickly.

If you're using Safari it's true that Safari's WebAssembly implementation is behind the other browsers. But that's a Safari problem more than a WebAssembly problem.

> I'd rather we just move to native cross platform applications and stop using a document browser to build interactive applications.

Go back to garbage "cross platform" UI toolkits and having to help users manage software dependencies on their machine? No thanks.

> I'd rather we just move to native cross platform applications and stop using a document browser to build interactive applications.

Cool stuff, let's kill web for good.

Throwing out the baby with the bath water? There are millions of standardized APIs available in the browser that would be probably impossible to recreate in anything else due to failing consensus.

Assembly is not a language runtime. Even if you had WebAssembly as the core, you'd still need to compile JavaScript to WebAssembly, manage the GC, etc which all would still suffer from the performance implications mentioned in the article.

Also... do you really think its wise to rewrite v8 to target WebAssembly?

It already supports WebAssembly. All browsers do.

Here's a demo of Dart and Flutter compiled to WebAssembly:

https://flutterweb-wasm.web.app/

WebAssembly enables you to use any language. And when you can use any language, why would you use JavaScript?

Google has started migrating parts of Google Sheets to WebAssembly. They're compiling Java to WebAssembly and seeing a 100% performance increase:

https://web.dev/case-studies/google-sheets-wasmgc

Amazon has been migrating its Prime Video app from JavaScript to WebAssembly. They're compiling Rust to WebAssembly and they've seen increased performance and lower memory usage:

https://www.amazon.science/blog/how-prime-video-updates-its-...

Then you add capability to hide the browser chrome and build close to native user experience and we will have truly looped the loop. Think about that: the browser as an intermediation ensuring resources are properly shared and each application is shielded from the others. Everything that’s old is new again. /s

On a serious note I don’t see the point in turning browsers into an OS on top of the OS. I know it’s some kind of Google wet dream so they can suck up even more data than they already do but still. If you want to ship applications, just do that. The sandboxing should be done at the OS level where it belongs.

I was in your camp, but we truly lost. Almost everyone I know literally ONLY uses a browser for everything. On mobile some things force you app use, but if that weren't the case, people would use it from a browser. Games in browsers, movies, email, anything. So it makes sense to only open a browser in an OS; it is basically what users do anyway.

Reply on news.ycombinator.com