reference-types

> It could be an interesting use case for WASM if the problem of passing data into the WASM VM cheaply (perhaps by reference) can be solved. WASM Reference Types should hopefully solve this. The WASM working group seems to have some good momentum - so I'm hopeful this (or a similar replacement spec) will land sooner rather than later. https://github.com/WebAssembly/reference-types/blob/master/p...

AFAIK GC is (mostly) irrelevant for "direct DOM access", you would rather want to hop into the following rabbit hole: - reference types: https://github.com/WebAssembly/reference-types/blob/master/p... - interface types (inactive): https://github.com/WebAssembly/interface-types/blob/main/pro... - component model: https://github.com/WebAssembly/component-model If this looks like a hot mess, that's because it is. Compared to that, the current solution to go through a Javascript shim doesn't look too bad IMHO.

> I don't think WASM should/would unify the GC across memory models WASM already has a GC proposal[0] which is already at the "Implementation stage"[1] so it looks like this IS going to happen, although it's uncertain if language runtimes like Go will actually make use of the feature, or what. [0]: https://github.com/WebAssembly/gc/blob/main/proposals/gc/Ove... [1]: https://github.com/WebAssembly/proposals A glance of the overview and spec seems to indicate that WASM will provide some primitive data types, and any GC language can build their implementation on top of it. As I understand it, it's heavily based on Reference Types[3], which allows acting on host-provided types, and is already considered part of the spec [4]. It doesn't remove the need for the 5 different runtimes to have their own GC, but it lowers the bulk that the runtimes

> And there's been talk of exposing the JS GC to wasm for a few years. Hopefully when that stuff lands, it'll get easier to marshal objects across the gap. You don't need a Wasm GC to do this. If you only need js objects to pass on to, say, the host's function or check is null or not, then reference types that are opaque external references: https://github.com/WebAssembly/reference-types/blob/master/p... You can even do many more things if you export `Reflect` to WebAssembly: https://github.com/AssemblyScript/assemblyscript/blob/main/t... Reference Types are available almost everywhere already (In Safari will be available after 15.0): https://webassembly.org/roadmap

Wasm is not basically assembler, it's (going to be) very high level: - https://github.com/WebAssembly/reference-types - https://github.com/webassembly/threads - https://github.com/WebAssembly/exception-handling - https://github.com/WebAssembly/function-references - https://github.com/WebAssembly/gc Though it is true that the original MVP was very barebone and could be compared to assembler. However, the reference types proposal has been shipped in all major browsers and is considered "finished".

It does feel like WebAssembly development has stalled after the initial release. There are proposals for reference types, garbage collection, and host bindings that would greatly expand a WebAssembly binary's capabilities, but they haven't been implemented in any browser, much less standardized yet. WebAssembly proposals tracker: https://github.com/WebAssembly/proposals WebAssembly reference types (https://github.com/WebAssembly/reference-types/blob/master/p...) looks like the blocker for a lot of things, and it's in the final spec phase at least. In Chrome, it's behind a flag since 78, which went stable in Oct 22 2019: https://chromestatus.com/features/5166497248837632 But also under active development? https://bugs.chromium.org/p/v8/issues/detail?id=7581 Supposedly implemented in Firefox two years ago: https://bugzilla.mozilla.org/sho

You might find these interesting: - https://github.com/WebAssembly/gc - https://github.com/WebAssembly/reference-types - https://github.com/WebAssembly/funclets As for the eval thing, you surely can compile and execute code on the fly. Such features would be enabled by the aforementioned proposals, but should be possible today as well (through shared memory).

There is no if, DOM access is already at Stage 3. https://github.com/WebAssembly/reference-types Besides there is already WebGL, WebAudio and WebGPU is being worked on.

It can, and the proposal is at stage 3. https://github.com/WebAssembly/reference-types/blob/master/p...

WASM ref handles for DOM nodes is comming. https://github.com/WebAssembly/reference-types/blob/master/p...

Ah interesting - so my thinking on this is: - I see that I poorly communicated this in the title, but I was actually shooting less for "Rust/WASM makes this better!!" and more for "Hey, this is possible with pretty much just Rust/WASM!" I ended up hand writing about 10 lines of JS [1] in total - More minor point - WebGL commands don't need to be called via JS [2] after anyref and host bindings land, and I think that it's important for people to know that it's possible to do things on the web without JS (whether that's a good idea is very situational)! So yeah apologies if the title could be a bit better - but the main goal was to share with others that it's possible to build 3d experiences on the web with Rust today! And - just to not come off wrong here - I'm not saying whether this is right or wrong and when to go this route. I am just

Minor clarification: The DOM builtins should be helped by the Reference Types Proposal for WebAssembly. [1] `The host bindings proposal` is going to help speed up new and getter/setter calls. [2] 1: `Currently the only built-ins that we support this for are mostly limited to the math built-ins. That’s because WebAssembly currently only has support for integers and floats as value types. That works well for the math functions because they work with numbers, but it doesn’t work out so well for other things like the DOM built-ins. So currently when you want to call one of those functions, you have to go through JavaScript. That’s what wasm-bindgen does for you. But WebAssembly is getting more flexible types very soon. Experimental support for the current proposal is already landed in Firefox Nightly behind the pref javascript.options.wasm_g

I think that will come fairly soon - I forgot to mention that the reference types proposal also include multiple table support https://github.com/WebAssembly/reference-types/blob/master/p...

Let me count the ways: - code size - a runtime for a managed language is much bigger if you have to reimplement & ship the primitives you get from the JS platform. - implementation complexity: a LLVM-webassembly-toolchain along with your own GC is much harder and more work than a JS backend, and would need to have a rather good payoff to be worth investing in. - poor cross-browser development tooling support to have a good debugging experience - GC implementation complexity and performance - firstly, there is no GC support currently and no timeline about when/if something materalizes. The current "future GC" support in webassembly[1] doesn't provide a GC implemnetation, just hooks to peacefully coexist with JS GC. - JS interop - browser support Now, it may be that some of these get solved eventually - but they would all have to be solved,

Looking forward to ref types[0] and host bindings[1] so this stuff doesn't get too JS-specific. The former has seen a good bit of activity recently. 0 - https://github.com/WebAssembly/reference-types 1 - https://github.com/WebAssembly/host-bindings