glob-match VS design

You might be interested in @devongovett's `glob_match` library (written in Rust): https://github.com/devongovett/glob-match

Logisim.app runs directly in your browser thanks to WebAssembly, a powerful browser technology that makes it possible to run complete desktop-class applications entirely client-side.

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.

Tools like Figma offer the performance of native software applications with the distribution of a website. Their existence is made possible by two relatively new technologies, Web Assembly (or WASM) and WebGL. WASM is an assembly language that allows programs written in C++, C, Rust, and other languages to be compiled and run in web browsers. WebGL is a graphics library and API that allows for fine-grain control over what is rendered on-screen. Much more control than what is possible using standard web languages like HTML, JS, and CSS.

Check WebAssembly

➡️ WebAssembly Official Documentation

Blazor WASM applications are compiled into WebAssembly and run entirely on the browser. While you can host a Blazor WASM application on any web server (standalone Blazor WASM), a specific hosting model called ASP.NET Core hosted model allows you to simply host your application within an ASP.NET Core application, giving you more control over some server-side functionality.

It’s clear WebAssembly is one of the more popular up-and-coming technologies out there. Its promise, a universal executable format, is not new. In fact it dates back to 1995 (almost thirty years ago!) with Java. Arguably, Java was successful in some areas, many enterprise software is built on Java after all, it tried for a brief time (Java Web Start) and eventually failed to ride the stellar rise of the world wide web. Microsoft .NET is a younger contender, but it arguably suffering from the same adoption challenge as Java. While it can run on most systems now, the web is still not one of them.

Official WebAssembly Website Emscripten

I don't think that terminology is "overwhelmingly common", and I'd argue that it isn't even entirely correct. The JVM is widely deployed, the Ethereum VM is called the "EVM", https://www.linuxfoundation.org/hubfs/LF%20Research/The_Stat... describes BPF and eBPF repeatedly as "virtual machines", https://webassembly.org/ begins by saying, "WebAssembly (abbreviated Wasm) is a binary instruction format for a stack-based virtual machine," etc. "Virtual machine" is still the most common term for virtual machines.

You can't always use the term "emulator" instead of "virtual machine", because while you could say wasmtime was an "emulator", you can't correctly say that WebAssembly itself is an "emulator". Rather, WebAssembly is the virtual machine which wasmtime emulates. It's also common to call emulators "virtual machines". (The Wasmtime web site mostly calls wasmtime a "runtime" and WebAssembly an "instruction format", FWIW.) And of course a running instance of an emulator is also a "virtual machine" in a different sense.

I think it's also reasonable to use "virtual machine" in the way you are describing, and it has some overlap with this last sense of "virtual machine". Perhaps in your current environment that is the overwhelmingly most common usage, but that is definitely not true elsewhere.

But wait, you say! That is an extreme undertaking. LAPACK is vast, with approximately 1,700 routines, and implementing even 10% of them within a reasonable time frame is a significant challenge. Wouldn't it be better to just compile LAPACK to WebAssembly, a portable compilation target for programming languages such as C, Go, and Rust, which enables deployment on the web, and call it a day?