WebAssembly
WebAssembly
WebAssembly (often shortened to Wasm) is an open standard that defines a portable binary code format for executable programs, and a corresponding textual assembly language, as well as interfaces for facilitating interactions between such programs and their host environment.[2][3][4][5] The main goal of WebAssembly is to enable high performance applications on web pages, but the format is designed to be executed and integrated in other environments as well.[6][7]
Wasm does not replace JavaScript; in order to use Wasm in browsers, users may use Emscripten SDK to compile C++ (or any other LLVM-supported language such as D or Rust) source code into a binary file which runs in the same sandbox as regular JavaScript code;[1] Emscripten provides bindings for several commonly used environment interfaces like WebGL; it has access only to an expandable memory and a small number of scalar values. There is no direct Document Object Model (DOM) access; however, it is possible to create proxy functions for this, for example through stdweb,[12] web_sys,[13] and js_sys.[14]
The World Wide Web Consortium (W3C) maintains the standard with contributions from Mozilla, Microsoft, Google, and Apple.[15]
History
WebAssembly was first announced in 2015,[16] and the first demonstration was executing Unity's Angry Bots in Firefox,[17] Google Chrome,[18] and Microsoft Edge.[19] The precursor technologies were asm.js from Mozilla and Google Native Client,[20][21] and the initial implementation was based on the feature set of asm.js.[22]
In March 2017, the design of the minimum viable product (MVP) was declared to be finished and the preview phase ended.[23] In late September 2017, Safari 11 was released with support. In February 2018, the WebAssembly Working Group published three public working drafts for the Core Specification, JavaScript Interface, and Web API.[24][25][26][27]
Support
In November 2017, Mozilla declared support "in all major browsers"[28] (by now all major on mobile and desktop), after WebAssembly was enabled by default in Edge 16.[29] The support includes mobile web browsers for iOS and Android. As of September 2019, 87.42% of installed browsers (89.39% of desktop browsers and 87.4% of mobile browser) support WebAssembly.[30] But for older browsers, Wasm can be compiled into asm.js by a JavaScript polyfill.[31]
Because WebAssembly executables are precompiled, it is possible to use a variety of programming languages to make them.[32] This is achieved either through direct compilation to Wasm, or through implementation of the corresponding virtual machines in Wasm. There have been around 40 programming languages reported to support Wasm as a compilation target.[33]
Its initial aim is to support compilation from C and C++,[34] though support for other source languages such as Rust and .NET languages is also emerging.[35][36][33] After the MVP release, there are plans to support multithreading and garbage collection[37][38] which would make WebAssembly a compilation target for garbage-collected programming languages like C# (supported via Blazor) and F# (supported via Bolero[39] with help of Blazor); Java, Julia,[40][41][42] Ruby,[43] as well as Go.
Security considerations
In June 2018, a security researcher presented the possibility of using WebAssembly to circumvent browser mitigations for Spectre and Meltdown security vulnerabilities once support for threads with shared memory is added. Due to this concern, WebAssembly developers put the feature on hold.[44][45][46] Thread support was eventually added in October 2018.[47]
Features
Stack machine
Instruction set
The core standard defines a unique Instruction Set Architecture consisting of specific binary encoding and which is intended to be executed by VM. However it doesn't specify how exactly they must be invoked by it.[54]
Representation
In March 2017, the WebAssembly Community Group reached consensus on the initial (MVP) binary format, JavaScript API, and reference interpreter.[55] It defines a WebAssembly binary format, which is not designed to be used by humans, as well as a human-readable linear assembly bytecode format that resembles traditional assembly languages.
The table below represents three different views of the same source code input from the left, as it is converted to a Wasm intermediate representation, then to Wasm binary instructions:[56]
| C input source | Linear assembly bytecode (intermediate representation) | Wasm binary encoding (hexadecimal bytes) |
|---|---|---|
intfactorial(intn){if(n==0)return1;elsereturnn | get_local 0
i64.eqz
if (result i64)
i64.const 1
else
get_local 0
get_local 0
i64.const 1
i64.sub
call 0
i64.mul
end | 20 00
50
04 7E
42 01
05
20 00
20 00
42 01
7D
10 00
7E
0B |
The WebAssembly text format can also be written in a folded format using s-expressions. This format is purely syntactic sugar and has no behavioral differences with the linear format.[57] An example is shown below:
Literature
Haas, Andreas; Rossberg, Andreas; Schuff, Derek L.; Titzer, Ben L.; Gohman, Dan; Wagner, Luke; Zakai, Alon; Bastien, JF; Holman, Michael (June 2017). "Bringing the web up to speed with WebAssembly" [71] . Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation. Association for Computing Machinery: 185–200. doi:10.1145/3062341.3062363 [72] .
Watt, Conrad (2018). "Mechanising and Verifying the WebAssembly Specification" [73] (PDF). ACM SIGPLAN International Conference on Certified Programs and Proofs. ACM. 7. doi:10.1145/3167082 [74] .