Sign in

WebAssembly from the Ground Up

@wasmgroundup.com
273 followers 191 following 75 posts

A book about WebAssembly by @marianoguerra.org and @dubroy.com — learn Wasm by building a simple compiler in JavaScript. wasmgroundup.com

PostsRepliesMedia
WebAssembly from the Ground Up @wasmgroundup.com · 07/03/2026
Ohhh this is cool: github.com/dy/jz JS syntax that compiles to pure WASM. No runtime, no GC.
import jz from 'jz'

// 3 lines of JS → 120 bytes of WASM, compiles in <1ms
const { exports } = await WebAssembly.instantiate(jz(`
  let { sin, PI } = Math
  export let sine = (out, freq, t) => {
    for (let i = 0; i < out.length; i++) out[i] = sin((t + i) * freq * PI * 2 / 44100)
  }
`))

// Real-time audio at native speed, zero GC pauses
exports.sine(audioBuffer, 440, sampleOffset)
030
WebAssembly from the Ground Up @wasmgroundup.com · 26/02/2026
Is it the end of February already?? Yes, yes it is. Which means we just sent out our #Wasm tidbits. Sign up here to get it in your inbox once a month (ish): sendfox.com/wasmgroundup
Ahoy!

Hope your February has been swell. Here in southern Germany, it's been a relatively snowy winter…but it's finally starting to feel like spring.

First and foremost, we wanted to let you know that we published a new blog post last week, A WebAssembly interpreter (Part 2). In Part 1, we created a simple Wasm interpreter from scratch, but it was only able to evaluate expressions consisting of literals. In the latest post, we add support for local and global variables. Give it a look!

And here are your Wasm tidbits for February:
 • "WebCC is a lightweight, zero-dependency C++ toolchain and framework for building WebAssembly applications. It provides a direct, high-performance bridge between C++ and HTML5 APIs." And then there's Coi, "a modern, component-based language for building reactive web apps", which is built on WebCC. 
 • Marimo is an open-source reactive Python notebook; like Jupyter, but better in many ways (no hidden state, stored as pure Python files, …). And it also supports WebAssembly notebooks, powered by Pyodide; in other words, Wasm notebooks execute entirely in the browser, without a backend executing Python. 
 • Along the same lines: Pandoc for the People is a fully-featured GUI interface for Pandoc (probably the most-used Haskell program ever). It lets you run any kind of conversion that pandoc supports, without the documents ever leaving your computer. It's based on the recent Pandoc 3.9 release, which supports Wasm via the GHC wasm backend.
042
WebAssembly from the Ground Up @wasmgroundup.com · 23/02/2026
We've released a new version of @wasmground/emit — the small, simple #Wasm 1.0 "assembler library" for JS/TS, which we build up piece by piece in our book. The headline feature: proper TypeScript types! Give it a spin and let us know what you think: www.npmjs.com/package/@was...
import * as w from "@wasmgroundup/emit";

const mod = w.module([
  w.typesec([w.functype([w.valtype.i32, w.valtype.i32], [w.valtype.i32])]),
  w.funcsec([w.typeidx(0)]),
  w.exportsec([w.export_("add", w.exportdesc.func(w.funcidx(0)))]),
  w.codesec([
    w.code(
      w.func(
        [],
        w.expr([
          [w.instr.local.get, ...w.i32(0)],
          [w.instr.local.get, ...w.i32(1)],
          w.instr.i32.add,
        ]),
      ),
    ),
  ]),
]);

const { instance } = await WebAssembly.instantiate(w.flatten(mod));
const { add } = instance.exports as { add: (a: number, b: number) => number };
console.log(add(1, 2)); // 3
1122
WebAssembly from the Ground Up @wasmgroundup.com · 30/01/2026
Just sent out our #Wasm tidbits for January. All the coolest kids at FOSDEM subscribe, why don't you? sendfox.com/wasm...
Hey y'all — Some of you might be on your way to FOSDEM, or already there; if so, have fun! Looks like there won't be a WebAssembly devroom this year, but there are a few Wasm talks on the schedule.



Anyways, here are your Wasm tidbits for January:



 • eBPF.party is a set of hands-on exercises to learn about eBPF. It features a browser-based live feedback editor for C code, powered by TCC (Tiny C Compiler) compiled to Wasm. 
 • Meet Whamm: The WebAssembly Instrumentation Framework.
 • Building docfind: Fast Client-Side Search with Rust and WebAssembly has some details on how the VS Code team built a client-side search engine for their documentation.
 • The 2025 Web Almanac from the Http Archive has some interesting details about how Wasm is being used on the web: "We periodically crawl the top sites on the web and record detailed information about fetched resources, used web platform APIs and features, and execution traces of each page…then crunch and analyze this data to identify trends."
031
WebAssembly from the Ground Up @wasmgroundup.com · 18/12/2025
We just sent out our last newsletter of the year, chock full of Wasm tidbits and captivating compiler content. Not signed up? You're missing out! Get on the list at sendfox.com/wasmgroundup
Wasm tidbits

 • All the videos from the WebAssembly Workshop at ICFP/SPLASH '25 are up on YouTube. There are a bunch of interesting ones, but we particularly enjoyed Oscar Spencer's Wasm GC and the Future of High-Level Language Compilation.
 • The Feature Status page on webassembly.org has been updated to include a bunch of new engines and tools, including Wizard, wazero, and Binaryen.
 • It's not directly related to WebAssembly, but we've been following Matt Godbolt's Advent of Compiler Optimizations, and it's been great so far. It's a nice way to learn a bit more about x86 and ARM assembly, and about the various optimizations that C++ compilers do. You can follow it on his blog or on YouTube.
 • Andy Wingo: "If anyone has never worked on a baseline compiler before, they are a really funny space; my first experience with Firefox's Wasm baseline compiler was an eye-opener for me." Firefox's low-latency WebAssembly compiler (2020).
 • For a deeper look at strategies for baseline compilation, see Ben Titzer's Whose baseline compiler is it anyway?. "We demystify single-pass compilers for Wasm, explaining their internal algorithms and tradeoffs, as well as providing a detailed empirical study of those employed in production." 
 • We recently met some folks from CedarDB (the commercial version of the Umbra database system), who told us about how they use Wasm for user-defined operators. The details can be found in Moritz Sichert's PhD dissertation, Efficient and Safe Integration of User-Defined Operators into Modern Database Systems.
171
WebAssembly from the Ground Up @wasmgroundup.com · 09/12/2025
A very readable doc about V8's new bytecode verifier. Readers of our book may notice the similarity to the Wasm security model — see this excerpt from the chapter "What makes WebAssembly safe?"
Excerpt from the V8 Sandbox - Bytecode Verification doc, reading:

"The bytecode verifier needs to ensure that the execution of verified bytecode does not lead to out-of-sandbox corruption, specifically stack corruption. As the bytecode is fairly simple, this reduces down to a few basic properties that must be verified:
Spatial memory safety: stores (and potentially loads) to/from the stack stay inside the stack frame and so do not corrupt stack memory
Control-flow Integrity (CFI): jumps within the bytecode land at a valid instruction (otherwise, we might execute arbitrary instruction and so the first property could not be guaranteed)
No unsafe functions: the bytecode should not call unsafe runtime or native functions

These properties are verifiable in linear time (constant per bytecode) with a relatively simple validator."An excerpt from WebAssembly from the Ground Up, showing a section entitled "Sandboxed execution". The excerpt reads:

"WebAssembly sandboxed execution is based on a technique known as Software-based Fault Isolation (SFI). It’s a remarkably simple idea. Here’s how it works —

The “sandbox” consists of two regions of memory: a code region and a data region. Then, the host must enforce two policies:

- A data-access policy ensures that any memory access in the untrusted module can only target its designated data region.
- A control-flow policy ensures that the untrusted module can’t transfer control outside its own code region — except by calling explicitly-allowed functions."
001
WebAssembly from the Ground Up @wasmgroundup.com · 04/12/2025
I don't check LinkedIn very often, but today it was worth it. 😊
I'm a few chapters in, and the book truly exemplifies iterative learning 'from the ground up'. It starts with atomic units and the simplest thing that could possibly work, but then each chapter builds on the previous, while not jumping over any gaps. As an author, I appreciate how much thought went into creating that experience, but as a reader, it's just a smooth ride. Thanks Mariano Guerra and Patrick Dubroy for such an excellent book. I highly recommend it!
020
WebAssembly from the Ground Up @wasmgroundup.com · 21/11/2025
One of our goals in the book was to encourage readers to become familiar with the WebAssembly spec. That's why, in the library we create for producing Wasm modules, we aim for "eye-closeness" with the spec. Left: code from the book. Right: the 1.0 spec text.
// im*:vec(import)
export function importsec(ims) {
  return section(SECTION_ID_IMPORT, vec(ims));
}

// mod:name  nm:name  d:importdesc
export function import_(mod, nm, d) {
  return [name(mod), name(nm), d];
}

export const importdesc = {
  // x:typeidx
  func(x) {
    return [0x00, typeidx(x)];
  },
};
Excerpt from the WebAssembly core specification show § 5.5.5. Import Section, and the definitions of `importsec`, `import`, and `importdesc`.
100
WebAssembly from the Ground Up @wasmgroundup.com · 21/11/2025
Oh hey! We're on the HN front page 😄 If you've read the book and enjoyed it, and feel like leaving a comment, it would certainly help us out!
A screenshot of the Hacker News front page. Post #5 is circled in bright pink — the title is "WebAssembly from the Ground Up", and it has 105 point and 19 comments.
020
WebAssembly from the Ground Up @wasmgroundup.com · 20/11/2025
Wasm Maze by Kenny Fully → kennyfully881230.github.io/wasm_fun/was... "I ended up learning a lot about how to use linear memory to render one time to the canvas on every frame. Not only that, I learn how to do collisions, sprite clipping etc all in Wasm." Source code: github.com/kennyfully88...
020
WebAssembly from the Ground Up @wasmgroundup.com · 14/10/2025
Interesting paper presented at MPLR yesterday — "A Snapshot of the Performance of Wasm Backends for Managed Languages" → users.cs.northwestern.edu/~robby/pubs/... Benchmarks Wasm implementations of Dart, Haskell, Scheme, OCaml, Ruby against the native impls.
Abstract
WebAssembly (Wasm) has been extended to support features
such as garbage collection, references, exceptions, and tail
calls that facilitate compilation of managed languages. In
this paper, we capture a snapshot of the performance of languages that use these new capabilities from two perspectives.
First, we present a language-by-language performance comparison of six managed language implementations on Wasm
to the performance to their native implementations. Second, we focus on the implementation of the Bigloo Scheme
compiler and explore the impact of different choices for compiling specific aspects of the language. Our findings suggest
that Wasm has become a promising compilation target for
most managed languages, but that its performance still falls
short of that achieved by native code. Our results also show
that the quality of the Wasm implementations vary, with the
best ones being, on average, about 1.4× slower than the native backend and the worst ones seeing average slowdowns
of more than 8× with some tests even failing to execute
correctly.

Disclaimer
☞ This study contains no novelty regarding compilation
or, more generally, implementation techniques. Its purpose is to provide information to language communities
about the state of existing Wasm backends. Specifically,
it offers information that sets some basic performance
expectations and it offers some experience with the performance of several specific compilation technique choices
in the context of the Bigloo Scheme compiler.
051
WebAssembly from the Ground Up @wasmgroundup.com · 29/09/2025
An interesting article about how Figma moved from WebGL to WebGPU — Figma rendering: Powered by WebGPU → www.figma.com/blog/figma-r... Also talks a bit about their overall app architecture, and how they use #wasm.
But how do we actually use WebGPU?

Our renderer is written in C++. We compile this C++ code to WebAssembly (Wasm) using Emscripten, in order to use it in the main Figma application. But we also compile our C++ renderer code into a native x64/arm64 application used for server-side rendering, as well as testing and debugging. So we needed a way to write code using the WebGPU C/C++ API and have it work in both cases, with minimal per-platform branching.

For Wasm, we decided to use Emscripten’s built-in WebGPU bindings support. This means that C++ WebGPU calls ultimately end up using the WebGPU browser API in JavaScript, even though our code is written in C++. We also had to write some of our own custom C++/JS bindings in cases where these built-in bindings weren’t performant enough.
031
WebAssembly from the Ground Up @wasmgroundup.com · 12/09/2025
Nice use of Wasm — bundling lightweight WebAssembly decoders with the data. AnyBlox: A Framework for Self-Decoding Datasets → gienieczko.com/anyblox-paper /ht Jamie Brandon (www.scattered-thoughts.net/log/0054/)
First page of an academic paper entitled "AnyBlox: A Framework for Self-Decoding Datasets", by Mateusz Gienieczko and four other authors (including Thomas Neumann), all from TU Munich.

The abstract reads: "Research advancements in storage formats continuously produce more efficient encodings and better compression rates. Despite this, new formats are not adopted due to high implementation cost and existing formats cannot evolve because they need to maintain compatibility across systems. Can this problem be solved by introducing a new abstraction? We answer affirmatively with AnyBlox, a frame work for reading arbitrary datasets using lightweight WebAssembly decoders bundled with the data. By decoupling decoders from both systems and file format specifications, AnyBlox allows transparent format evolution, instance-optimized encodings, and enables mainstream adoption of research advancements. It integrates seamlessly with modern systems like DuckDB, Spark, and Umbra, while delivering solid performance and security guarantees."

On the right, a colourful diagram is captioned: "The N ×M problem: In the past (left) every system controlled its data and internal format. Today (right) data is outside of systems’ control. No system supports all formats and each system has specialized glue code for each format."
1124
WebAssembly from the Ground Up @wasmgroundup.com · 26/06/2025
A good question we were asked recently — "Does V8 optimize WebAssembly similar to JS?" The latest post on the V8 blog, "Speculative Optimizations for WebAssembly using Deopts and Inlining", provides some answers! v8.dev/blog/wasm-s...
Fast execution of JavaScript relies heavily on speculative optimizations. That is, JIT-compilers make assumptions when generating machine code based on feedback that was collected during earlier executions. For example, given the expression a + b, the compiler can generate machine code for an integer addition if past feedback indicates that a and b are integers (and not strings, floating point numbers, or other objects). Without making such assumptions, the compiler would have to emit generic code that handles the full behavior of the + operator in JavaScript, which is complex and thus much slower. If the program later behaves differently and thus violates assumptions made when generating the optimized code, V8 performs a deoptimization (or deopt, for short). That means throwing away the optimized code and continuing execution in unoptimized code (and collecting more feedback to possibly tier-up again later).  In contrast to JavaScript, fast execution of WebAssembly hasn’t required speculative optimizations and deopts. One reason is that WebAssembly programs can already be optimized quite well because more information is statically available as e.g., functions, instructions, and variables are all statically typed. Another reason is that WebAssembly binaries are often compiled from C, C++, or Rust. These source languages are also more amenable to static analysis than JavaScript, and thus toolchains such as Emscripten (based on LLVM) or Binaryen can already optimize the program ahead-of-time. This results in fairly well-optimized binaries, at least when targeting WebAssembly 1.0, which launched in 2017.
083
WebAssembly from the Ground Up @wasmgroundup.com · 25/04/2025
Wireworld is a kind of cellular automaton, similar to Conway's Game of Life. Wasm4-Wireworld is an implementation of Wireworld WASM-4 "fantasy console" using Hoot, a Scheme-to-Wasm compiler: spritely.institute/news/hoot-wi...
051
WebAssembly from the Ground Up @wasmgroundup.com · 17/04/2025
Great article by @saelo.bsky.social about the V8 sandbox: v8.dev/blog/sandbox "the overall construction is therefore not unlike the sandboxing model used by WebAssembly"
After almost three years since the initial design document and hundreds of CLs in the meantime, the V8 Sandbox — a lightweight, in-process sandbox for V8 — has now progressed to the point where it is no longer considered an experimental security feature. Starting today, the V8 Sandbox is included in Chrome's Vulnerability Reward Program (VRP). While there are still a number of issues to resolve before it becomes a strong security boundary, the VRP inclusion is an important step in that direction. Chrome 123 could therefore be considered to be a sort of "beta" release for the sandbox. This blog post uses this opportunity to discuss the motivation behind the sandbox, show how it prevents memory corruption in V8 from spreading within the host process, and ultimately explain why it is a necessary step towards memory safety.  Motivation Memory safety remains a relevant problem: all Chrome exploits caught in the wild in the last three years (2021 – 2023) started out with a memory corruption vulnerability in a Chrome renderer process that was exploited for remote code execution (RCE). Of these, 60% were vulnerabilities in V8. However, there is a catch: V8 vulnerabilities are rarely "classic" memory corruption bugs (use-after-frees, out-of-bounds accesses, etc.) but instead subtle logic issues which can in turn be exploited to corrupt memory. As such, existing memory safety solutions are, for the most part, not applicable to V8. In particular, neither switching to a memory safe language, such as Rust, nor using current or future hardware memory safety features, such as memory tagging, can help with the security challenges faced by V8 today.
051
WebAssembly from the Ground Up @wasmgroundup.com · 10/04/2025
Just published a new release of the book with some minor updates: • Added "debugging" section to About the Code • Appendix now has all remaining instructions from the 1.0 spec • (PDF) Fixed some code blocks which didn't show full contents +More! It's all in the changelog.
As you follow along with the code in the book, you may find yourself needing to debug some generated wasm. One of the best tools for doing that is Yury Delendik’s WebAssembly Code Explorer. You can upload a .wasm file, and it will show you an interactive visualization along a the text representation of the module (.wat).  It even works with modules that are not valid. Note that if the module is invalid, the output you see might look very different from what you’re expecting. But often, seeing how how the module is parsed — especially when it’s different from what you intended — is enough to realize where the problem is.  We also recommend installing the wabt (WebAssembly Binary Toolkit) tools. You can find installation instructions on the GitHub page.
020
WebAssembly from the Ground Up @wasmgroundup.com · 10/04/2025
Something handy for anyone who's trying to debug generated wasm… A PR of ours was merged into the wabt repo yesterday. In the JS version of wasm2wat, you can now opt to skip validation — just like the `--no-check` option in the CLI. Try it out here: webassembly.github.io/wabt/demo/w...
The image shows a web page titled "wasm2wat demo”, showing a tool that converts WebAssembly binary format to text format. The interface features multiple checkboxes for various WebAssembly features, and options to pass to wasm2wat.  There's a pink arrow labeled "New!” pointing to the checkbox for “Check for invalid modules”.
011
WebAssembly from the Ground Up @wasmgroundup.com · 12/03/2025
Here's a peek inside the book. You can also read a few sample chapters here: wasmgroundup.com/book/content...
An excerpt from the book, showing a section title "Our first compiler".

Let’s create a function that:
- Takes the code for a program as input.
- “Parses” it by checking that it’s a valid program, in this case the empty string.
- Returns an array of bytes which encodes a minimal WebAssembly module.
012
WebAssembly from the Ground Up @wasmgroundup.com · 10/03/2025
Excited to announce the official launch of our online book, WebAssembly from the Ground Up! 🎉 It's the book we wish we'd had 3 years ago. No messing with tools and frameworks. It's a hands-on guide to the core of Wasm: the instruction set and module format. Link below. 👇
Learn Wasm by building a simple compiler in JavaScript. No compiler expertise necessary. All the code is in the book; we'll take you through it step by step. Get your hands dirty and see for yourself what WebAssembly is all about.
27334
WebAssembly from the Ground Up @wasmgroundup.com · 24/02/2025
With the official launch of the book being next week, we figured it's about time we wrote a Conclusion chapter 😅 Lots more small tweaks & improvements coming this week…
A table of contents page for 'WebAssembly from the Ground Up' with a purple 'WA' logo. The page is divided into sections: Start, Main Track, Deep Dives, and Finish. The Main Track section includes topics like 'Minimum Viable Compiler', 'Writing a Compiler with Ohm', and several other chapters including two bonus sections marked with sparkle emojis. Some entries in the Deep Dives and Finish sections are marked as 'Draft'. A cartoon pair of eyes appears in the bottom right corner with a pink arrow pointing to the 'Conclusion' section.A conclusion page from a WebAssembly book, titled 'Conclusion' with the subtitle 'What we covered (and what we didn't)'. The text discusses the book's focus on WebAssembly Core Specification 1.0, listing four main topics covered: the execution model, binary module format (.wasm), validation rules, and text format (.wat). The text explains that the book primarily focused on the first two topics while acknowledging that not everything could be covered comprehensively.
022
WebAssembly from the Ground Up @wasmgroundup.com · 14/02/2025
Just published another update to the book: a draft of our last technical chapter, "Odds & Ends". 🎉 It covers a few features that we didn't have room for in the main track of the book: global variables, tables, and the element section.
"A table of contents showing the structure of a technical book or guide about compilers and programming. The content is divided into sections: START (with Introduction and About the Code), MAIN TRACK (containing topics like Minimum Viable Compiler, Writing a Compiler with Ohm, and various programming concepts), DEEP DIVES (with technical topics like Variable-Length Integer Encoding), and FINISH (with Conclusion and final sections). Some entries are marked as 'Draft' or 'Planned'. There's a pink arrow pointing to 'Appendix: Odds & Ends' with text saying 'The last technical chapter!!!'"A documentation page about WebAssembly global variables. The left side shows a navigation menu with sections like 'Odds and Ends', 'Export types', and 'Global variables'. The main content includes explanatory text and two code blocks in dark mode. The first code block shows global instruction definitions in JavaScript with hexadecimal values (0x23 and 0x24). The second code block contains more complex JavaScript code defining global section constants and functions, including SECTION_ID_GLOBAL set to 6, mutation types, and helper functions for handling global variables. The code is syntax-highlighted in shades of blue and white
153
WebAssembly from the Ground Up @wasmgroundup.com · 31/01/2025
Happy Friday! We've just published a draft of the FINAL technical chapter of the book. It's called "What Makes WebAssembly Safe?" and we think you're going to enjoy it.
141
WebAssembly from the Ground Up @wasmgroundup.com · 24/01/2025
Nice to see that @moonbitlang.bsky.social is continuing to make progress! MoonBit is a new, Wasm-native programming language with a syntax similar to Rust (although it has a GC): docs.moonbitlang.com/en/latest/
000
WebAssembly from the Ground Up @wasmgroundup.com · 18/01/2025
SpiderMonkey WASI demo — the SpiderMonkey JS engine, compiled to WebAssembly, running in the browser → mozilla-spidermonkey.github.io/sm-wasi-demo/
052
WebAssembly from the Ground Up @wasmgroundup.com · 28/12/2024
Love this idea! WebAssembly Wizardry: "Tiny programming challenges designed for learning about WebAssembly by writing it by hand." → github.com/danprince/w...
050
WebAssembly from the Ground Up @wasmgroundup.com · 21/12/2024
Hello! We're looking for 1-2 people **who've already bought the book but haven't yet started** and are interesting in working through the first 1-2 chapters LIVE on a video call with me. Interested? Reply here or to the post on the #announcements channel in the book's Discord.
100
WebAssembly from the Ground Up @wasmgroundup.com · 16/12/2024
This is the final chapter in the main part of the book. That means…we're almost done! With today's release, we've also removed draft status from Chap. 7–9. Early next year, we'll be releasing the final chapter, a deep dive on what makes WebAssembly "safe". And then…launch! 🚀
041
WebAssembly from the Ground Up @wasmgroundup.com · 16/12/2024
Hello Wasmites — We've got a big update for you today, just in time for the holidays! It's a draft of Chapter 10: Arrays and Strings. 🎉 This is definitely one of the most technically challenging chapters of the book…but we think you're going to like it!
Arrays and Strings
In the last chapter, we added basic support to Wafer for reading and writing linear memory. We can now create modules with memory, and access it directly as if it was a single big array of i32 values.

Our first goal in this chapter is to use that functionality to add support for regular, dynamically-allocated i32 arrays. In order to do that, we’ll need to write a simple memory allocator. Then, building on i32 arrays, we’ll add support for strings to Wafer — which means we’ll finally be able to write “Hello, world!”Bounds checking
We can make our arrays more user friendly by implementing bounds checking. That is, before reading or writing memory, we’ll check that the index is valid — that it’s within the bounds of the array.

The way we’ll do that is by storing the array length at the beginning of every array. So an array of length 2 will now take up three i32 slots: one for the length, and two for the entries themselves.
120
WebAssembly from the Ground Up @wasmgroundup.com · 12/12/2024
It's really good news for dynamic languages. WasmGC is now supported in all the major browsers and JS runtimes.
A compatibility table showing WebAssembly feature support across different platforms and browsers. The table includes logos for Chrome, Firefox, Safari, Node.js, Deno, GraalWasm, Wastime, and Wasmer. The row highlighted in pink shows "Garbage Collection" feature support, with version numbers 119 for Chrome, 120 for Firefox, 18.2 for Safari, 22.0 for Node.js, and 1.38 for Deno
010
WebAssembly from the Ground Up @wasmgroundup.com · 12/12/2024
Big news! Safari 18.2 is out, with support for WasmGC and tail calls: webkit.org/blog/16301/...
WebKit for Safari 18.2 adds support for WASM Garbage Collection. It allows WebAssembly modules to define a variety of new reference types whose memory is managed automatically by the browser. These types range from simple data types like structs and arrays, to more complex type relationships such as subtyping and recursion. Without WASM GC, source languages that rely on garbage collection (such as Java, C#, Kotlin, Go, and others) generally have to write their own garbage collectors and compile them to WebAssembly.

…

WebKit for Safari 18.2 also adds support for WASM Tail Calls, which allows WebAssembly modules to call functions while reusing the current stack frame.
141
WebAssembly from the Ground Up @wasmgroundup.com · 11/12/2024
Turns out there's a lot of stuff to cover before we can print to the console. - Building an instantiating modules - Defining functions - Importing functions - Linear memory etc. Yes, we like doing things the hard way.
000
WebAssembly from the Ground Up @wasmgroundup.com · 11/12/2024
Many programming books start with a small program that prints "Hello, world.” But this book is different. It's only at the end of Chapter 10 that we're ready to tackle that. 😅 Looking forward to releasing the draft very soon!
1121
WebAssembly from the Ground Up @wasmgroundup.com · 22/11/2024
Some *very* interesting Wasm-related features in the latest version of Deno (v2.1): docs.deno.com/runtime/reference/wasm • Import .wasm modules directly • Calls into WebAssembly are type checked (!) • Wasm modules can import .ts modules directly (!!)
074
WebAssembly from the Ground Up @wasmgroundup.com · 22/11/2024
Hello, World! (from the ground up)
051