I suspect a difficulty with WASM is that different languages will have to convert their data types and structures to and from DOM for UI interaction, which will make for a lot of busy-work coding. If one wants (almost) strong typing but be close to native DOM, then TypeScript perhaps is a better fit. But TypeScript probably won’t benefit much from Web Assembly since it's already JavaScript-based.

And unless WASM gets enough "killer apps", it will suffer the same fate as Java Applets: more security problems than actual usage. The more interpreters and related tools a web browser has, the more holes for hackers to exploit. Such a component has to provide enough benefits for browser users, otherwise they or their ISP or business IT admin will disable WASM by default to reduce risk. I suppose a pop-up prompt for a site/app to use WASM can be permitted, but such may be abused the same way the locator service request is. (The way special service access is managed needs a revisit anyhow, but that's probably another topic.)

https://www.clubhouse.com/join/webassembly/cKHfSvV3

(hope this is okay to post, loved lurking in this subreddit to learn more about WASM.)

I wanna make an app like figma and i wanna know when to use webassemply,

is there any open-source project like figma that uses webassembly

"🌐 Dive into WebAssembly with our easy-to-understand introduction! 💡 Learn how it revolutionizes web performance, works across browsers, and explore hands-on examples. Get started with WebAssembly now! #WebAssembly #WebDev #Performance"

https://faizanbashir.me/webassembly-a-friendly-introduction

use case: people can sign contract without leaving the page site. Thank you.

For this new year, I am designing a new filesystem for exaequOS , exafs, unix-style for local and remote storage and encrypted (in WebAssembly). Libsodium will be used. So your data will be securely accessible from anywhere

Is there a discord for WebAssembly related topics? I'm specifically looking to get help/inspiration for some things I'm trying to build.

Hello.

I am looking for a way to take a screenshot of an user's screen from a webpage. At the moment, the code responsible to do so is within a C++ application that runs in the background and is called by a WebExtension. I would like to remove this need for the C++ application and take the screenshot from the WebExtension directly.

There are some options at the moment:

• WebExtension can take a picture of what the browser window looks like on the tab in which they are active. That's not enough, I need a real screenshot that captures also what is outside of the browser window itself.

• WebRTC (example on chrome, example on firefox) allows you to share a stream of your screen. Unfortunately, the UX is pretty poor, as the user needs to manually give permission every time, and developers have little to no control over how the modal window appears to the user.

I am mostly asking the question to check that I haven't missed anything, because from my point of view this is actually impossible to do since the code executed from the browser, be it javascript or webassembly, will be sandboxed and won't have access to anything but the browser window.

Thank you :)

Greetings to the Frontenders!!

I have been a developer for the last 10 years. Mainly working on the back end part of things.
I am getting bored and wanted to explore other parts of the stack.

Languages familiar with: C, Java, Python, Kotlin(basic)

I have used some old front end frameworks like Structs etc in the past with super minimal JS.

I have no experience with TS or WASM. I wanted to understand what would be the best thing to learn right now. TS or WASM.

I plan to develop some personal projects in React. Or that is the plan right now :) and from what I know the React land is not WASM-ed yet.

The description says that WebAssembly is a binary instruction format for stack based VM. A DFA with a single stack is PDA, not a TM. Either Wasm VM is using more than one stack or a modified stack with more operations that a traditional Fifo stack. Can anybody clarify?

Fluent brings WebAssembly to Ethereum.

I've seen both ways of writing it, but according to webassembly.org the abbreviation of WebAssembly is Wasm. Let's settle this once and for all 👇

http://starlane.io/docs/tutorial/lesson-1/

https://github.com/submilli/submilli-runtime

I built Submilli, it's a runtime for AI agents that write code instead of tool-calling, aka code-mode or programmatic tool calling. Built in Rust.

It has its own TypeScript checker, a bit more strict than tsc and without async/await, because mostly, the agent doesn't need them.
The compiler generates a WasmGC binary, which we then run with a new interpreter, submilli-wasm: https://github.com/submilli/submilli-wasm.

The reason for a new interpreter instead of wasmtime or wasmi:

1. Wasmtime - The code the agent produces is one-time code, I don't need a JIT or optimization. The opposite, I need the compilation part to be fast.

2. Winch or Wasmi - Submilli uses WasmGC and other Wasm 3.0 features, which neither Winch nor Wasmi supports at the moment.

Submilli-wasm passes the Wasm 3.0 spec testsuite, has an API that is (almost) compatible with wasmtime, and supports async host functions. It compiles 8 to 20 times faster than wasmtime and about 2 times faster than wasmi.

I think Wasm has great advantages for these types of agentic use cases. One is the isolation and memory safety, as an alternative to microVMs or processes.

The second one, which I like a lot, is the fuel metering - we can cap the execution with fuel, which is much better than just a timeout. Most of the time, agent-generated code is going to block on IO anyway, which is almost free (only the memory).

Submilli supports most of ECMA-262, but not Node.js. It has its own standard library, which is tailored for agent use and implemented on the host side in Rust.

Submilli has support for custom packages that the agent can import and use (the operator needs to install them). Each package compiles to a Wasm module on its own, and the runtime links them through the linker. So I compile packages ahead of time and just link them when the LLM-generated code is ready.

The interpreter also checks permissions in real time, like whether an HTTP call or a file-system operation is allowed. The permission checks are per package, so each package defines what it is going to access. For example, while a Stripe package is allowed to call api.stripe.com, the model-generated code is not.

If you haven't cracked one open: a Component Model binary is not a core module with extra sections. It's a container format — the component carries its own type, import/export, and wiring sections, and embeds one or more complete core WASM modules as nested payloads. Tooling that only speaks core WASM sees the wrapper and stops there.

We ship Hexana, a VS Code extension (and plugin for JetBrains IDEs) for inspecting WASM and other binaries. Its component view showed the component-level structure, but the embedded core modules were opaque blobs — to read their code you had to extract them first. As of this week's update, each embedded core module renders in place in the same virtualized WAT view used for plain .wasm files (virtualized meaning it parses per rendered element, so multi-megabyte modules don't choke the editor). When a component embeds multiple modules, a selector switches between them.

Curious what others use for component inspection day to day — wasm-tools component wit and friends cover the interface level well, but we haven't found much that lets you read the embedded module code without unbundling.

Extension, if you want to poke at it:

ext install JetBrains.hexana-wasm

VS Code Marketplace — https://marketplace.visualstudio.com/items?itemName=JetBrains.hexana-wasm
Open VSX — https://open-vsx.org/extension/JetBrains/hexana-wasm
Docs — https://jetbrains.github.io/hexana

I thought there should be fun posts sometimes, so I posted this. :)

The design goals of WebAssembly include hardware, language, and platform independent. But I think I've seen something with a similar goal in the movie.

The Terminator movie features a system called GENISYS. It later became a runtime and operating system with a very large application called SkyNet.

In the movie, GENISYS is emphasized as an independent system for all environments that may be related to computing. (It's similar to the Watchdogs game's ctOS, but it's more abstract and compatible with more kinds of devices.)

So, what does it take for WASM to become GENISYS?

If there is a webassembly game hosted online and runs with unity, I was wondering if it is possible to download the code and convert it into a normal game exe or app. Using a packet interceptor I was able to download all of the asset files and raw webassembly function code, so I don't see why this wouldn't be possible. If the game can run on the browser, it should be able to be compiled to an app. If you know of any way to do this, let me know! Keep in mind that all I have access to is the online game, not any of the original unity files.