design

This physics engine is a deterministic physics engine. It has to be to make sure that when it rolls back and resimulates forward, it gets the same answer on all machines. The determinism is partly possible because WebAssembly is deterministic (except for a few known cases https://github.com/WebAssembly/design/blob/main/Nondetermini...), and partly because I’m making sure to use my own trigonometric functions, and the entire game simulation is executed single threaded with a known order of execution. If you meant to ask how does it compare to non deterministic physics engines, I’m sure they might be faster on the physics but would be slower on the rollback, and I think on most reasonably-sized games the slow rollback would dominate and so they would be slower overall. But, you wouldn’t make a rollback netcode game with that size of world a

I'm writing a new Wasm GC language because I'm so unsatisfied with the current options. I'm three months in, and so for it's mostly good. WASM takes care of all the GC bits, but in turn you have to use its ref, struct, and array types for everything. Making vtables is straight forward. Fat pointers for interfaces require an object though, since you can't do your own pointer layout. In web contexts GC should be great because browser GCs can work across DOM, JS, and WASM, so you can hold a reference to a node that you get via JS, and if you remove the node from the DOM and discard the reference, it'll be collected just like in JS. The big downside is data transfer over the Wasm boundary requires a lot more copying with GC. Byte arrays like (array i8) are completely opaque to the outside, so you need to vend individual byte access functions

> (Cue deterministic WASM derivations) "Rah Rah, this is why we need deterministic wasm derivations!" - Me (There you go Ericson) Relevant links: https://github.com/WebAssembly/design/blob/main/Nondetermini...

Does this allow for shrinking the WebAssembly.Memory object? - https://github.com/WebAssembly/design/issues/1397 - https://github.com/WebAssembly/memory-control/issues/6 This is a crucial issue, as the released memory is still allocated by the browser.

I advocated for PrefixVarint (which seems equivalent to vint64 ) for WebAssembly, but it was decided against, in favor of LEB128: https://github.com/WebAssembly/design/issues/601 The recent CREL format for ELF also uses the more established LEB128: https://news.ycombinator.com/item?id=41222021 At this point I don't feel like I have a clear opinion about whether PrefixVarint is worth it, compared with LEB128.

My understanding is that chaining compressors is a classic technique for image compression. IIRC PNG and Basis are both implemented as initial transformation/pre-filtering/conditioning pass(es) designed to make the image data more compressible before feeding it to a codec like gzip or zstd. This definitely works for things that aren't images too. I previously proved that you could improve the compression ratio for WebAssembly significantly by performing lossless transforms on the module before feeding it to gzip or brotli (though the gains are much smaller for brotli since it's so good to begin with): https://github.com/WebAssembly/design/issues/1180

See for example https://github.com/WebAssembly/design/issues/1463 In general, if NaN1 and NaN2 are different (there are 23 bits in a NaN that can be set to an arbitrary value, the NaN payload) then combining them isn’t deterministic. NaN1 + NaN2 might produce NaN1 or NaN2 depending on the processor model, instructions etc. IEEE754 only says that the result must be one of the two input NaNs (or at least it did last time I checked the standard.) In practice, NaN payloads are seldomly used so it doesn’t matter much. NaN canonicalization involves transforming all NaNs to specific NaN values, and AFAIK it’s expensive because technically you need to check for NaN all the time.

I found a discussion with some explanations to why that is and what other solutions could be looked at: https://github.com/WebAssembly/design/issues/1184

I should add, however, that the unmentioned elephant in the room is V8 JIT (TurboFan), which simply doesn't handle irreducible control flow. While there are some valid theoretical arguments around the current arrangement in Wasm, looking at the history of the associated discussions makes it pretty obvious that having V8 support Wasm and generate fast code similar to what it can do for asm.js was an overriding concern in many cases. And Google straight up said that if Wasm has ICF, they will not bother supporting such cases, so it will be done by a much slower fallback: https://github.com/WebAssembly/design/issues/796#issuecommen... AFAIK no other Wasm implementation has the same constraint - the rest generally tend to desugar everything to (potentially irreducible) CFG and then proceed from there. So this is, at least to some extent, yet

https://github.com/WebAssembly/design/issues/1397 > Currently allocating more than ~300MB of memory is not reliable on Chrome on Android without resorting to Chrome-specific workarounds, nor in Safari on iOS. That's about allocating CPU memory but the GPU memory situation is similar. The specs don't want to reveal information about how much memory you're allowed to use because it could be used for fingerprinting, but that means that it's practically impossible to build reliable applications which use (or can optionally use) a lot of memory. Every allocation you make past a few hundred MB risks blowing up the app immediately, or putting it into the danger zone where it's the first in line to get killed when running in the background, either way without any warning or last-chance opportunity to release memory to avert getting killed.

As far as I can tell (5 minutes of internet research) this was to allow easier compilation to JavaScript as a fallback in the days when WASM wasn't widely supported. "Please add goto" issue has been open since 2016: https://github.com/WebAssembly/design/issues/796 Most interesting comment: > The upcoming Go 1.11 release will have experimental support for WebAssembly. This will include full support for all of Go's features, including goroutines, channels, etc. However, the performance of the generated WebAssembly is currently not that good. > This is mainly because of the missing goto instruction. Without the goto instruction we had to resort to using a toplevel loop and jump table in every function. Using the relooper algorithm is not an option for us, because when switching between goroutines we need to be able to resume execution at dif

Quite a letdown that the solution for a web-based spreadsheet is for users to install a local backend. Might be a case for edge computing even. > WebAssembly has a single contiguous, linear memory space shared by all dynamic memory allocations. This means that WASM cannot make use of several memory management features that operating systems provide, such as Virtual Memory, Swapping, etc. Additionally, it cannot make use of the CPU’s MMU optimisations such as prefetching and caching. WebAssembly has memory issues, but those are not them. Virtual memory and swapping are OS features that work at the page level. CPU prefetching and caching are CPU features that work at the cacheline/address level. [1] covers the major design limitations with WebAssembly memory. [1] https://github.com/WebAssembly/design/issues/1397

Wasm itself provides some determinism constraints[1] as an explicit design goal, which is what enables things like this. I made a very simple snapshottable compute executer for a talk last year and it took surprisingly little code if you want a look at how it works[2], but the complexity of something like Flawless is that doing anything useful involves communicating with the outside world, where non-determinism can easily sneak in. I've been following Bernard's work on Lunatic so I'm incredibly excited to see he's tackling these hard problems. [1] https://github.com/WebAssembly/design/blob/main/Nondetermini... [2] https://github.com/drifting-in-space/wasmbox/tree/main

When I implemented a WASM compiler, the only source of float-based non-determinism I found was in the exact byte representation of NaN. Floating point math is deterministic. See https://webassembly.org/docs/faq/#why-is-there-no-fast-math-... and https://github.com/WebAssembly/design/blob/main/Nondetermini....

> To work with GC, you need some way to track if the GC'd object is accessible in WASM itself. I've never heard of a GC with that kind of API. Usually any native code that holds a GC reference would either mark that reference as a root explicitly (eg. https://github.com/WebAssembly/design/issues/1459) or ensure that it can be traced from a parent object. Either way, this should prevent collection of the object for as long as the reference is reachable from a root. I agree that explicitly checking whether a GC'd object has been freed would not make any sense. > The reason why you probably need a custom string type is so you can actually embed string literals without relying on interop with the environment. WASM already has ways of embedding flat string data. This can be materialized into GC/heap objects at module startup. This must ha