View source for WebAssembly

'''WebAssembly''' ('''Wasm''') defines a [[Software portability|portable]] [[Binary code|binary-code]] format and a corresponding text format for [[Executable|executable programs]]<ref>{{cite web |author1=Mozilla |title=Understanding WebAssembly text format |url=https://developer.mozilla.org/en-US/docs/WebAssembly/Understanding_the_text_format |access-date=9 December 2019 |website=MDN Web Docs |language=en-US |archive-date=5 February 2022 |archive-url=https://web.archive.org/web/20220205193242/https://developer.mozilla.org/en-US/docs/WebAssembly/Understanding_the_text_format |url-status=live }}</ref> as well as [[Software|software]] interfaces for facilitating communication between such programs and their host environment.<ref>{{Cite web|
url=https://webassembly.github.io/spec/core/intro/introduction.html|
title=Introduction — WebAssembly 1.0|
website=webassembly.github.io|
access-date=18 June 2019|
quote=WebAssembly is an open standard...|
archive-date=22 November 2021|
archive-url=https://web.archive.org/web/20211122194356/https://webassembly.github.io/spec/core/intro/introduction.html|
url-status=live}}</ref><ref>{{Cite web|
url=https://webassembly.github.io/spec/core/intro/introduction.html|
title=Introduction — WebAssembly 1.0|
website=webassembly.github.io|
access-date=18 June 2019|
quote=WebAssembly is a ... code format|
archive-date=22 November 2021|
archive-url=https://web.archive.org/web/20211122194356/https://webassembly.github.io/spec/core/intro/introduction.html|
url-status=live}}</ref><ref name=":0">{{Cite web|
url=https://webassembly.github.io/spec/core/syntax/conventions.html|
title=Conventions — WebAssembly 1.0|
website=webassembly.github.io|
access-date=17 May 2019|
quote=WebAssembly is a programming language that has multiple concrete representations (its binary format and the text format). Both map to a common structure.|
archive-date=6 May 2019|
archive-url=https://web.archive.org/web/20190506193348/https://webassembly.github.io/spec/core/syntax/conventions.html|
url-status=live}}</ref><ref>{{Cite web|
url=https://webassembly.github.io/spec/core/intro/introduction.html|
title=Introduction — WebAssembly 1.0|
website=webassembly.github.io|
access-date=18 June 2019|
quote=... this specification is complemented by additional documents defining interfaces to specific embedding environments such as the Web. These will each define a WebAssembly application programming interface (API) suitable for a given environment.|
archive-date=22 November 2021|
archive-url=https://web.archive.org/web/20211122194356/https://webassembly.github.io/spec/core/intro/introduction.html|
url-status=live}}</ref>

The main goal of WebAssembly is to facilitate high-performance applications on [[Web page|web page]]s, but it is also designed to be usable in non-web environments.<ref>{{Cite web|
title=Introduction — WebAssembly 1.1|
url=https://webassembly.github.io/spec/core/intro/introduction.html|
access-date=2021-02-19|
quote=Its main goal is to enable high performance applications on the Web, but it does not make any Web-specific assumptions or provide Web-specific features, so it can be employed in other environments as well.|
website=webassembly.github.io|
archive-date=22 November 2021|
archive-url=https://web.archive.org/web/20211122194356/https://webassembly.github.io/spec/core/intro/introduction.html|
url-status=live}}</ref> It is an [[Engineering:Open standard|open standard]]<ref>{{Cite journal|
last1=Haas|first1=Andreas|
last2=Rossberg|first2=Andreas|
last3=Schuff|first3=Derek L.|
last4=Titzer|first4=Ben L.|
last5=Holman|first5=Michael|
last6=Gohman|first6=Dan|
last7=Wagner|first7=Luke|
last8=Zakai|first8=Alon|
last9=Bastien|first9=JF|
date=14 June 2017|
title=Bringing the Web Up to Speed with WebAssembly|
journal=SIGPLAN Notices|volume=52|issue=6|pages=185–200|doi=10.1145/3140587.3062363|issn=0362-1340|
quote=While the Web is the primary motivation for WebAssembly, nothing in its design depends on the Web or a JavaScript environment. It is an open standard specifically designed for embedding in multiple contexts, and we expect that stand-alone implementations will become available in the future.|doi-access=free}}
</ref><ref name=":1"/> intended to support any language on any operating system,<ref name="Wasmer" /> and in practice many of the most popular languages already have at least some level of support.

Announced in {{Start date|2015}} and first released in {{Start date|2017|3}}, WebAssembly became a [[Organization:World Wide Web Consortium|World Wide Web Consortium]] (W3C) recommendation on 5 December 2019<ref>{{cite web |
author1=World Wide Web Consortium |
title=WebAssembly Core Specification |
url=https://www.w3.org/TR/wasm-core-1/ |
website=World Wide Web Consortium (W3) |
access-date=9 December 2019 |
archive-date=6 December 2019 |
archive-url=https://web.archive.org/web/20191206110848/https://www.w3.org/TR/wasm-core-1/ |
url-status=live }}</ref><ref>{{cite web |
last1=Couriol |
first1=Bruno |
title=WebAssembly 1.0 Becomes a W3C Recommendation and the Fourth Language to Run Natively in Browsers |
url=https://www.infoq.com/news/2019/12/webassembly-w3c-recommendation/ |
website=infoq.com |
access-date=9 December 2019 |
archive-date=25 November 2021 |
archive-url=https://web.archive.org/web/20211125151735/https://www.infoq.com/news/2019/12/webassembly-w3c-recommendation/ |
url-status=live }}</ref><ref>{{Cite web|title=WebAssembly Specification — WebAssembly 1.1|url=https://webassembly.github.io/spec/core/|access-date=2021-03-22|website=webassembly.github.io|archive-date=22 September 2022|archive-url=https://web.archive.org/web/20220922054129/https://webassembly.github.io/spec/core/|url-status=live}}</ref> and it received the ''Programming Languages Software Award'' from [[Organization:Association for Computing Machinery|ACM]] SIGPLAN in 2021.<ref>{{Cite web|
url=http://www.sigplan.org/Awards/Software/|
title=Programming Languages Software Award|
website=www.sigplan.org|
access-date=5 October 2021|
archive-date=29 October 2022|
archive-url=https://web.archive.org/web/20221029011704/http://www.sigplan.org/Awards/Software/|
url-status=live}}</ref> The W3C maintains the standard with contributions from Mozilla, [[Company:Microsoft|Microsoft]], [[Company:Google|Google]], [[Company:Apple Inc.|Apple]], [[Company:Fastly|Fastly]], [[Company:Intel|Intel]], and [[Company:Red Hat|Red Hat]].<ref name="ars"/><ref name="bytecode"/>

== History ==
The name WebAssembly is intended to suggest bringing [[Assembly language|assembly language]] programming to the [[World Wide Web]], where it will be executed [[Client–server model|client-side]], by the website-user's computer via the user's [[Software:Web browser|web browser]]. To accomplish this, WebAssembly must be much more hardware-independent than a true assembly language.

WebAssembly was first announced in 2015,<ref name="Launch bug"/> and the first demonstration was executing [[Software:Unity (game engine)|Unity]]'s ''Angry Bots'' in [[Software:Firefox|Firefox]],<ref name="Unity in Firefox"/> [[Software:Google Chrome|Google Chrome]],<ref name="V8 blog"/> and Microsoft Edge [Legacy].<ref name="Edge"/> The precursor technologies were [[Asm.js|asm.js]] from Mozilla and [[Software:Google Native Client|Google Native Client]],<ref name="techcrunch2015"/><ref name="PNaCl"/> and the initial implementation was based on the feature set of asm.js.<ref name="initial implementation"/>{{Refn|group=note|The asm.js file already provides near-native code execution speeds: "Even discarding the one score where asm.js did better, it executes at around 70% of the speed (i.e., slower) of native C++ code.<ref>{{Cite web|url=https://blog.mozilla.org/javascript/2013/08/01/staring-at-the-sun-dalvik-vs-spidermonkey/|title=Staring at the Sun: Dalvik vs. ASM.js vs. Native|website=blog.mozilla.org|date=August 2013|access-date=7 December 2019|archive-date=7 December 2019|archive-url=https://web.archive.org/web/20191207155602/https://blog.mozilla.org/javascript/2013/08/01/staring-at-the-sun-dalvik-vs-spidermonkey/|url-status=live}}</ref> and can be considered a viable alternative for browsers that do not support WebAssembly or have it disabled for security reasons.}}

In March 2017, the design of the [[Engineering:Minimum viable product|minimum viable product]] (MVP) was declared to be finished and the preview phase ended.<ref name="MVP"/> In late September 2017, [[Software:Safari (web browser)|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.<ref name="W3C-WD2018" /><ref name="W3C-CSWD2018" /><ref name="W3C-JIWD2018" /><ref name="W3C-WAWD2018" />

In June 2019, Chrome 75 was released with WebAssembly threads enabled by default.<ref>{{Cite web|title=WebAssembly Worker Based Threads - Chrome Platform Status|url=https://chromestatus.com/feature/5724132452859904|access-date=2022-02-19|website=chromestatus.com|archive-date=19 February 2022|archive-url=https://web.archive.org/web/20220219194348/https://chromestatus.com/feature/5724132452859904|url-status=live}}</ref>

{{as of|April 2022|since=y|post=,}} WebAssembly 2.0 has been in draft status.<ref>{{Cite web |title=WebAssembly Specification — WebAssembly 2.0 (Draft 2022-09-01) |url=https://webassembly.github.io/spec/core/ |access-date=2022-09-09 |website=webassembly.github.io |archive-date=22 September 2022 |archive-url=https://web.archive.org/web/20220922054129/https://webassembly.github.io/spec/core/ |url-status=live }}</ref><ref>{{Cite web |title=WebAssembly 2.0 First Public Working Drafts {{!}} W3C News |date=19 April 2022 |url=https://www.w3.org/blog/news/archives/9509 |access-date=2022-09-09 |language=en-US |archive-date=9 September 2022 |archive-url=https://web.archive.org/web/20220909170347/https://www.w3.org/blog/news/archives/9509 |url-status=live }}</ref> It adds many [[SIMD]]-related instructions and a new v128 datatype, with the ability for functions to return multiple values, and mass memory initialize/copy.

== Implementations ==
While WebAssembly was initially designed to permit near-native code execution speed in the web browser, it has been considered valuable outside of such, in more generalized contexts.<ref name="nonweb">{{cite web|title=Non-Web Embeddings|url=https://webassembly.org/docs/non-web/|access-date=15 May 2019|work=WebAssembly|archive-date=15 May 2019|archive-url=https://web.archive.org/web/20190515113613/https://webassembly.org/docs/non-web/|url-status=live}}</ref><ref name="nonwebsrc">{{cite web|title=Non-Web Embeddings|url=https://github.com/WebAssembly/design/blob/master/NonWeb.md|access-date=15 May 2019|work=[[GitHub]] / WebAssembly|archive-date=13 November 2020|archive-url=https://web.archive.org/web/20201113115203/https://github.com/WebAssembly/design/blob/master/NonWeb.md|url-status=live}}</ref> Since WebAssembly's runtime environments (RE) are low-level [[Stack machine|virtual stack machines]] (akin to [[Java virtual machine|JVM]] or [[Software:Adobe Flash|Flash VM]]) that may be embedded into host applications, some implementations create standalone runtime environments like {{wdrl|Q119398768}} and {{wdrl|Q105554548}}.<ref name=":1">{{Cite web|title=Outside the web: standalone WebAssembly binaries using Emscripten · V8|url=https://v8.dev/blog/emscripten-standalone-wasm#running-in-wasm-runtimes|access-date=2020-07-28|website=v8.dev|archive-date=19 July 2020|archive-url=https://web.archive.org/web/20200719222947/https://v8.dev/blog/emscripten-standalone-wasm#running-in-wasm-runtimes|url-status=live}}</ref><ref name="Wasmer">{{Cite web|title=Wasmer - The Universal WebAssembly Runtime|url=https://wasmer.io/|quote=Compile everything to WebAssembly. Run it on any OS or embed it into other languages.|access-date=2021-02-19|website=wasmer.io|archive-date=2 March 2021|archive-url=https://web.archive.org/web/20210302014031/https://wasmer.io/|url-status=live}}</ref> WebAssembly runtime environments are embedded in [[Application server|application server]]s to host "server-side" WebAssembly applications and in other applications to support [[Plug-in (computing)|plug-in]]-based software extension architectures, e.g., "WebAssembly for Proxies" (Proxy-Wasm) which specifies a WebAssembly-based [[Application binary interface|ABI]] for extending [[Proxy server|proxy server]]s.<ref>{{cite web |url=https://konghq.com/blog/engineering/proxy-wasm |last=Freese |first=Danny |date=2023-10-03 |df=mdy |title=Proxy-Wasm: It's WebAssembly for Proxies |department=Blog |website=[[Company:Kong Inc.|Kong]] |access-date=2024-05-06}}</ref><ref>{{cite web |url=https://github.com/proxy-wasm/spec |title=proxy-wasm/spec: WebAssembly for Proxies (ABI specification) |website=[[GitHub]] |access-date=2024-05-06 |archive-date=6 May 2024 |archive-url=https://web.archive.org/web/20240506195418/https://github.com/proxy-wasm/spec |url-status=live }}</ref>

=== Web browsers<span class="anchor" id="Support"></span> ===
In November 2017, Mozilla declared support "in all major browsers",<ref name="in browsers"/> after WebAssembly was enabled by default in Edge [Legacy] 16.<ref name="Edge16"/> This support also includes mobile web browsers for iOS and Android. <!-- While outdated, no longer supported, Android 4.4.4 KitKat and older versions don't have WebView support, Android 5 does. --> {{As of|2024|3|post=,}} 99% of tracked web browsers <!-- 98.77%, 97.35% including browsers not tracked --> support WebAssembly (version 1.0),<ref name="canIuse.com"/> more than for its predecessor [[Asm.js|asm.js]].<ref>{{Cite web |title=asm.js {{!}} Can I use... Support tables for HTML5, CSS3, etc |url=https://caniuse.com/asmjs |access-date=2024-09-29 |website=caniuse.com}}</ref> <!-- For older browsers, Wasm can be compiled into asm.js by a JavaScript [[Polyfill (programming)|polyfill]].<ref name="ars2015"/> --> For some extensions, from the 2.0 draft standard, support may be lower, but still more than 90% of web browsers may already support, e.g. the reference types extension.<ref>{{Cite web |title=WebAssembly Reference Types {{!}} Can I use... Support tables for HTML5, CSS3, etc |url=https://caniuse.com/wasm-reference-types |access-date=2024-03-03 |website=caniuse.com}}</ref>

=== Compilers ===
WebAssembly implementations generally use either [[Ahead-of-time compilation|ahead-of-time]] (AOT) or [[Just-in-time compilation|just-in-time]] (JIT) compilation, though some may also use an [[Interpreter (computing)|interpreter]]. While the first implementations appeared in web browsers, there are now many non-browser implementations for general-purpose use.

==== Implementations and runtimes ====
Non-browser WebAssembly runtimes include Wasmer,<ref name="Wasmer"/> Wasmtime,<ref>{{cite web |title=Wasmtime — a small and efficient runtime for WebAssembly & WASI |url=https://wasmtime.dev/ |access-date=2020-12-18 |website=wasmtime.dev |archive-date=4 December 2020 |archive-url=https://web.archive.org/web/20201204101750/http://wasmtime.dev/ |url-status=live }}</ref> WAMR, WAVM, wasm3, and others.<ref>{{cite web |title=Roadmap |url=https://webassembly.org/roadmap/ |access-date=2021-12-07 |archive-date=7 December 2021 |archive-url=https://web.archive.org/web/20211207095013/https://webassembly.org/roadmap/ |url-status=live }}</ref> These systems execute precompiled Wasm modules and often provide additional APIs for embedding WebAssembly in different environments.

==== Compiler toolchains ====
Because WebAssembly executables are precompiled, a variety of programming languages can target Wasm.<ref name=AcceleratingWeb/> Compilation is achieved either through direct output to Wasm or via intermediate virtual machines implemented in Wasm.

Notable toolchains include:
* [[Software:Emscripten|Emscripten]], which compiles C and C++ to Wasm using Clang as a frontend, Binaryen as an optimizer, and can also target any LLVM-supported language.<ref name="MVP"/>
* Standalone [[Software:Clang|Clang]] (version 8 and later), which supports direct compilation to Wasm.<ref>{{cite web |title=LLVM 8.0.0 Release Notes — LLVM 8 documentation |url=https://releases.llvm.org/8.0.0/docs/ReleaseNotes.html#changes-to-the-webassembly-target |access-date=22 October 2019 |archive-date=22 October 2019 |archive-url=https://web.archive.org/web/20191022040310/http://releases.llvm.org/8.0.0/docs/ReleaseNotes.html#changes-to-the-webassembly-target |url-status=live }}</ref>
* LLVM-based workflows for languages such as Rust and AssemblyScript.<ref name="Implementations"/>

==== Language support ====
As of 2021, around 40 programming languages support WebAssembly as a compilation target.<ref name=Implementations/> Examples include:
* '''C and C++''': via Emscripten or Clang standalone.<ref name="MVP"/>
* '''Rust''': via rustc with Wasm target.<ref name="Rust"/><ref name="Implementations"/>
* '''AssemblyScript''': a TypeScript-like language compiling directly to Wasm.<ref>{{cite web |title=AssemblyScript/assemblyscript |date=2020-09-09 |url=https://github.com/AssemblyScript/assemblyscript |publisher=The AssemblyScript Project |access-date=2020-09-09 |archive-date=11 September 2020 |archive-url=https://web.archive.org/web/20200911072903/https://github.com/AssemblyScript/assemblyscript |url-status=live }}</ref>
* '''Go''': native WebAssembly support introduced in Go 1.11.<ref>{{cite web |last=Bonventre |first=Andrew |title=Go 1.11 is released |work=The Go Blog |date=2018-08-24 |url=https://go.dev/blog/go1.11 |access-date=2025-08-11 |archive-date=14 June 2025 |archive-url=https://web.archive.org/web/20250614013104/https://go.dev/blog/go1.11 |url-status=live }}</ref>
* '''.NET languages''': C# (via [[Software:Blazor|Blazor]]), F# (via Bolero and Blazor).<ref>{{cite web |title=Frequently asked questions (FAQ) about Blazor |url=https://blazor.net/docs/introduction/faq.html |access-date=18 June 2018 |archive-date=18 June 2018 |archive-url=https://web.archive.org/web/20180618230619/https://blazor.net/docs/introduction/faq.html |url-status=live }}</ref><ref>{{cite web |url=https://fsbolero.io/ |title=Bolero: F# in WebAssembly |website=fsbolero.io |access-date=25 July 2019 |archive-date=4 June 2019 |archive-url=https://web.archive.org/web/20190604231948/https://fsbolero.io/ |url-status=live }}</ref><ref>{{cite web |title=Running F# in WebAssembly with Bolero |url=https://learn.microsoft.com/en-us/shows/on-dotnet/f-sharp-wasm |website=Microsoft Learn |publisher=Microsoft |access-date=17 September 2025 |archiveurl = https://archive.today/20250917195346/https://learn.microsoft.com/en-us/shows/on-dotnet/f-sharp-wasm |archive-date=17 September 2025 |language=English |date=20 November 2019}}</ref>
* '''Python''': implementations such as Pyodide.<ref>{{cite web |title=Pyodide: Bringing the scientific Python stack to the browser – Mozilla Hacks |url=https://hacks.mozilla.org/2019/04/pyodide-bringing-the-scientific-python-stack-to-the-browser |access-date=2020-09-09 |archive-date=3 September 2020 |archive-url=https://web.archive.org/web/20200903004718/https://hacks.mozilla.org/2019/04/pyodide-bringing-the-scientific-python-stack-to-the-browser/ |url-status=live }}</ref>
* '''Java and JVM languages''': via CheerpJ,<ref>{{cite web |title=Java to WebAssembly Compiler - CheerpJ |url=https://leaningtech.com/cheerpj/ |access-date=2023-04-27 |archive-date=27 April 2023 |archive-url=https://web.archive.org/web/20230427165424/https://leaningtech.com/cheerpj/ |url-status=live }}</ref> JWebAssembly,<ref>{{cite web |title=JWebAssembly |url=https://github.com/i-net-software/JWebAssembly |date=27 April 2023 |via=GitHub |access-date=27 April 2023 |archive-date=27 April 2023 |archive-url=https://web.archive.org/web/20230427172728/https://github.com/i-net-software/JWebAssembly |url-status=live }}</ref> and TeaVM.<ref>{{cite web |title=TeaVM — Overview |url=https://www.teavm.org/docs/intro/overview.html |access-date=2023-04-27 |archive-date=27 April 2023 |archive-url=https://web.archive.org/web/20230427165425/https://www.teavm.org/docs/intro/overview.html |url-status=live }}</ref>
* '''Kotlin''': direct Wasm compilation support.<ref>{{cite web |title=Bringing Kotlin to the Web |url=https://developers.googleblog.com/2023/05/bringing-kotlin-to-web.html |access-date=2023-12-11}}</ref><ref>{{cite web |last=Deleuze |first=Sébastien |date=2023-02-13 |title=The huge potential of Kotlin/Wasm |url=https://seb.deleuze.fr/the-huge-potential-of-kotlin-wasm/ |access-date=2023-12-11}}</ref>
* '''Haskell''': supported via GHC backend.<ref>{{cite web |title=Using the GHC WebAssembly backend |url=https://ghc.gitlab.haskell.org/ghc/doc/users_guide/wasm.html |access-date=2025-05-01 |archive-date=1 May 2025 |archive-url=https://web.archive.org/web/20250501141624/https://ghc.gitlab.haskell.org/ghc/doc/users_guide/wasm.html |url-status=live }}</ref>
* '''Julia''': community implementations.<ref>{{cite web |url=https://nextjournal.com/sdanisch/wasm-julia |title=Julia in the Browser |website=nextjournal.com |access-date=9 April 2019 |archive-date=24 March 2019 |archive-url=https://web.archive.org/web/20190324202004/https://nextjournal.com/sdanisch/wasm-julia |url-status=live }}</ref>
* '''Ruby''': supported through MRuby.<ref>{{cite web |url=https://ruby.dj/ |title=MRuby in Your Browser |website=ruby.dj |access-date=25 July 2019 |archive-date=8 August 2019 |archive-url=https://web.archive.org/web/20190808160622/http://ruby.dj/ |url-status=live }}</ref>
* '''Ring''': supported with Wasm backend.<ref>{{cite web |url=https://www.infoworld.com/article/3572395/ring-language-upgrade-focuses-on-webassembly.html |title=Ring language upgrade focuses on WebAssembly |author=Paul Krill |date=24 August 2020 |publisher=InfoWorld |access-date=17 August 2024 |archive-date=14 October 2020 |archive-url=https://web.archive.org/web/20201014234517/https://www.infoworld.com/article/3572395/ring-language-upgrade-focuses-on-webassembly.html |url-status=live }}</ref>

==== Recent enhancements ====
Post-MVP developments in WebAssembly, such as support for multithreading and garbage collection (WasmGC), have enabled more efficient compilation for garbage-collected languages like C#, F#, and Python.<ref>{{cite web |title=WebAssembly Garbage Collection (WasmGC) now enabled by default in Chrome |url=https://developer.chrome.com/blog/wasmgc |access-date=2023-12-11}}</ref><ref>{{cite web |title=A new way to bring garbage collected programming languages efficiently to WebAssembly · V8 |url=https://v8.dev/blog/wasm-gc-porting#demo-and-status |access-date=2023-12-11}}</ref>

== Limitations ==

[[Software:Web browser|Web browser]]s do not permit WebAssembly code to directly manipulate the [[Document Object Model]]. Wasm code must defer to [[JavaScript]] for this.{{Refn|group=note|For [[Rust (programming language)|Rust]]/Wasm development, third-party libraries can provide some of the necessary JavaScript I/O.<ref>{{Cite web|url=https://docs.rs/stdweb/*/stdweb/|title=stdweb - Rust|website=docs.rs|access-date=5 June 2019|quote=The goal of this crate is to provide Rust bindings to the Web APIs and to allow a high degree of interoperability between Rust and JavaScript.|archive-date=21 February 2019|archive-url=https://web.archive.org/web/20190221034928/https://docs.rs/stdweb/%2A/stdweb/|url-status=live}}</ref><ref>{{Cite web|url=https://docs.rs/web-sys/*/web_sys/|title=web_sys - Rust|website=docs.rs|access-date=5 June 2019|quote=Raw API bindings for Web APIs. This is a procedurally generated crate from browser WebIDL which provides a binding to all APIs that browser provide on the web.|archive-date=15 May 2020|archive-url=https://web.archive.org/web/20200515170424/https://docs.rs/web-sys/0.3.39/web_sys/|url-status=live}}</ref>}}

In an October 2023 survey of developers, less than half of the 303 participants were satisfied with the state of WebAssembly. A large majority cited the need for improvement in four areas: WASI, debugging support, integration with JavaScript and browser APIs, and build tooling.<ref>{{cite web |title=The State of WebAssembly 2023 |url=https://blog.scottlogic.com/2023/10/18/the-state-of-webassembly-2023.html |publisher=Scott Logic |date=18 October 2023 |access-date=14 March 2024 |archive-date=14 March 2024 |archive-url=https://web.archive.org/web/20240314053648/https://blog.scottlogic.com/2023/10/18/the-state-of-webassembly-2023.html |url-status=live }}</ref>

For memory-intensive allocations in WebAssembly, there are "grave limitations that make many applications infeasible to be ''reliably'' deployed on mobile browsers [..] 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."<ref>{{Cite web|title=Wasm needs a better memory management story · Issue #1397 · WebAssembly/design|url=https://github.com/WebAssembly/design/issues/1397|access-date=2021-02-15|website=GitHub|language=en|archive-date=27 March 2021|archive-url=https://web.archive.org/web/20210327143806/https://github.com/WebAssembly/design/issues/1397|url-status=live}}</ref>

All major browsers allow WebAssembly if Content-Security-Policy is not specified, or if "unsafe-eval" is used, but behave differently otherwise.<ref>{{Cite web|title=WebAssembly/content-security-policy|url=https://github.com/WebAssembly/content-security-policy|access-date=2021-02-17|website=GitHub|language=en|archive-date=12 September 2020|archive-url=https://web.archive.org/web/20200912000113/https://github.com/WebAssembly/content-security-policy|url-status=live}}</ref> Chrome requires "unsafe-eval",<ref>{{Cite web|title=948834 - chromium - An open-source project to help move the web forward. - Monorail|url=https://bugs.chromium.org/p/chromium/issues/detail?id=948834&can=1&q=wasm-eval|access-date=2021-02-17|website=bugs.chromium.org|archive-date=2 June 2021|archive-url=https://web.archive.org/web/20210602213145/https://bugs.chromium.org/p/chromium/issues/detail?id=948834&can=1&q=wasm-eval|url-status=live}}</ref><ref name="ReferenceA">{{Cite web|title=No way to use WebAssembly on Chrome without 'unsafe-eval' · Issue #7 · WebAssembly/content-security-policy|url=https://github.com/WebAssembly/content-security-policy/issues/7|access-date=2021-02-17|website=GitHub|language=en|archive-date=18 March 2021|archive-url=https://web.archive.org/web/20210318122510/https://github.com/WebAssembly/content-security-policy/issues/7|url-status=live}}</ref> though a worker thread can be a workaround.<ref name="ReferenceA"/>

== Security considerations ==
In June 2018, a security researcher presented the possibility of using WebAssembly to circumvent browser mitigations for [[Spectre (security vulnerability)|Spectre]] and [[Meltdown (security vulnerability)|Meltdown]] security vulnerabilities once support for [[Thread (computing)|thread]]s with shared memory is added. Due to this concern, WebAssembly developers put the feature on hold.<ref name="forcepoint"/><ref name="bleeping computer">{{cite web |last1=Cimpanu |first1=Catalin |title=Changes in WebAssembly Could Render Meltdown and Spectre Browser Patches Useless |url=https://www.bleepingcomputer.com/news/security/changes-in-webassembly-could-render-meltdown-and-spectre-browser-patches-useless/ |publisher=[[Bleeping Computer]] |access-date=8 June 2019 |language=en-us |date=24 June 2018 |archive-date=10 July 2019 |archive-url=https://web.archive.org/web/20190710075136/https://www.bleepingcomputer.com/news/security/changes-in-webassembly-could-render-meltdown-and-spectre-browser-patches-useless/ |url-status=live }}</ref><ref name="tech republic">{{cite web |last1=Sanders |first1=James |title=How opaque WebAssembly code could increase the risk of Spectre attacks online |url=https://www.techrepublic.com/article/how-opaque-webassembly-code-could-increase-the-risk-of-spectre-attacks-online/ |website=Tech Republic |access-date=9 June 2019 |language=en |date=25 June 2018 |archive-date=9 June 2019 |archive-url=https://web.archive.org/web/20190609002418/https://www.techrepublic.com/article/how-opaque-webassembly-code-could-increase-the-risk-of-spectre-attacks-online/ |url-status=live }}</ref> However, in order to explore these future language extensions, Google Chrome added experimental support for the WebAssembly thread proposal in October 2018.<ref>{{cite web |last1=R |first1=Bhagyashree |title=Google Chrome 70 now supports WebAssembly threads to build multi-threaded web applications |url=https://hub.packtpub.com/google-chrome-70-now-supports-webassembly-threads-to-build-multi-threaded-web-applications/ |website=Packt Pub |access-date=9 June 2019 |date=30 October 2018 |archive-date=18 April 2019 |archive-url=https://web.archive.org/web/20190418150553/https://hub.packtpub.com/google-chrome-70-now-supports-webassembly-threads-to-build-multi-threaded-web-applications/ |url-status=live }}</ref>

WebAssembly has been criticized for allowing greater ease of hiding the evidence for [[Malware|malware]] writers, scammers and [[Phishing|phishing]] attackers; WebAssembly is present on the user's machine only in its compiled form, which "[makes malware] detection difficult".<ref name="virus bulletin">{{cite web |last1=Lonkar |first1=Aishwarya |last2=Chandrayan |first2=Siddhesh |title=The dark side of WebAssembly |url=https://www.virusbulletin.com/virusbulletin/2018/10/dark-side-webassembly/ |website=[[Virus Bulletin]] |access-date=8 June 2019 |date=October 2018 |archive-date=9 June 2019 |archive-url=https://web.archive.org/web/20190609000917/https://www.virusbulletin.com/virusbulletin/2018/10/dark-side-webassembly/ |url-status=live }}</ref> Speed and the easy ability to conceal in WebAssembly have led to its use in hidden [[Finance:Cryptocurrency#Mining|crypto mining]] within the website visitor's device.<ref name="virus bulletin"/><ref name="malwarebytes">{{cite web |last1=Segura |first1=Jérôme |title=Persistent drive-by cryptomining coming to a browser near you |url=https://blog.malwarebytes.com/cybercrime/2017/11/persistent-drive-by-cryptomining-coming-to-a-browser-near-you/ |publisher=[[Company:Malwarebytes|Malwarebytes]] |access-date=8 June 2019 |date=29 November 2017 |archive-date=15 April 2019 |archive-url=https://web.archive.org/web/20190415222635/https://blog.malwarebytes.com/cybercrime/2017/11/persistent-drive-by-cryptomining-coming-to-a-browser-near-you/ |url-status=live }}</ref><ref name="forcepoint">{{cite web |last1=Neumann |first1=Robert |last2=Toro |first2=Abel |title=In-browser mining: Coinhive and WebAssembly |url=https://www.forcepoint.com/blog/x-labs/browser-mining-coinhive-and-webassembly |publisher=Forcepoint |access-date=8 June 2019 |language=en |date=19 April 2018 |archive-date=9 June 2019 |archive-url=https://web.archive.org/web/20190609000928/https://www.forcepoint.com/blog/x-labs/browser-mining-coinhive-and-webassembly |url-status=live }}</ref> Coinhive, a now defunct service facilitating cryptocurrency mining in website visitors' browsers, claims their "miner uses WebAssembly and runs with about 65% of the performance of a native Miner."<ref name="forcepoint" /> A June 2019 study from the Technische Universität Braunschweig analyzed the usage of WebAssembly in the Alexa top 1 million websites and found the prevalent use was for malicious crypto mining, and that malware accounted for more than half of the WebAssembly-using websites studied.<ref>{{Cite web|url=https://www.infoq.com/news/2019/10/WebAssembly-wasm-malicious-usage/|title=Recent Study Estimates That 50% of Websites Using WebAssembly Apply It for Malicious Purposes|website=InfoQ|access-date=3 November 2019|archive-date=31 October 2019|archive-url=https://web.archive.org/web/20191031231650/https://www.infoq.com/news/2019/10/WebAssembly-wasm-malicious-usage/|url-status=live}}</ref><ref>{{cite book |last1=Musch |first1=Marius |title=Detection of Intrusions and Malware, and Vulnerability Assessment |volume=11543 |pages=23–42 |last2=Wressnegger |first2=Christian |last3=Johns |first3=Martin |last4=Rieck |first4=Konrad |chapter=New Kid on the Web: A Study on the Prevalence of WebAssembly in the Wild |url=https://www.sec.cs.tu-bs.de/pubs/2019a-dimva.pdf |publisher=Detection of Intrusions and Malware, and Vulnerability Assessment |access-date=15 February 2022 |doi=10.1007/978-3-030-22038-9_2 |date=June 2019 |series=Lecture Notes in Computer Science |isbn=978-3-030-22037-2 |s2cid=184482682 |archive-date=26 July 2022 |archive-url=https://web.archive.org/web/20220726131621/https://www.sec.cs.tu-bs.de/pubs/2019a-dimva.pdf |url-status=dead }} [https://www.dimva2019.org/wp-content/uploads/sites/31/2019/06/DIMVA19-slides-2-R.pdf Slides (PDF)] {{Webarchive|url=https://web.archive.org/web/20191103054140/https://www.dimva2019.org/wp-content/uploads/sites/31/2019/06/DIMVA19-slides-2-R.pdf |date=3 November 2019 }}</ref> An April 2021 study from [[Organization:University of Stuttgart|Universität Stuttgart]] found that since then crypto mining has been marginalized, falling to below 1% of all WebAssembly modules gathered from a wide range of sources, also including the Alexa top 1 million websites.<ref>Aaron Hilbig, Daniel Lehmann, and Michael Pradel (April 2021). "An Empirical Study of Real-World WebAssembly Binaries: Security, Languages, Use Cases." (Archived April 2021) https://software-lab.org/publications/www2021.pdf</ref> <!-- ORIGINAL URL WAS - DON'T KNOW HOW TO DO ARCHIVE-URL FOR CHAPTER: chapter-url=https://www.tu-braunschweig.de/Medien-DB/ias/pubs/2019-dimva.pdf -->

As WebAssembly supports only structured [[Control flow|control flow]], it is amenable toward security verification techniques including [[Symbolic execution|symbolic execution]].<ref>{{Cite book|last=Watt|first=Conrad|title=Proceedings of the 7th ACM SIGPLAN International Conference on Certified Programs and Proofs|chapter=Mechanising and verifying the WebAssembly specification|date=2018-01-08|chapter-url=https://dl.acm.org/doi/10.1145/3167082|series=CPP 2018|language=en|location=Los Angeles CA USA|publisher=ACM|pages=53–65|doi=10.1145/3167082|isbn=978-1-4503-5586-5|s2cid=9401691|url=https://www.repository.cam.ac.uk/handle/1810/274174|archive-date=1 March 2021|access-date=9 August 2023|archive-url=https://web.archive.org/web/20210301142910/https://www.repository.cam.ac.uk/handle/1810/274174|url-status=live}}</ref>

== Performance==
Benchmark results vary between implementations and between themselves. Performance was benchmarked early to be around 91% (i.e., 10% slower) for running code, not including load/instantiation time<ref>{{cite conference |conference=2019 USENIX Annual Technical Conference |location=Renton, WA |last1=Jangda |first1=Abhinav |last2=Powers |first2=Bobby |last3=Berger |first3=Emery |last4=Guha |first4=Arjun |title=Not So Fast: Analyzing the Performance of WebAssembly vs. Native Code |url=https://www.usenix.org/sites/default/files/atc19-full-proceedings.pdf |pages=107–120 |date=2019-05-31 |arxiv=1901.09056v3 |oclc=1106328738 |access-date=2025-03-20 |archive-date=20 March 2025 |archive-url=https://web.archive.org/web/20250320100609/https://www.usenix.org/sites/default/files/atc19-full-proceedings.pdf |url-status=live }}</ref> or more recently between 100% and 33% of native rates,<ref>{{cite web |last1=Denis |first1=Frank |title=Performance of WebAssembly runtimes in 2023 |url=https://00f.net/2023/01/04/webassembly-benchmark-2023/ |website=00f.net |date=4 January 2023 |access-date=6 December 2024}}</ref> and 120% of JavaScript (i.e. 20% faster).<ref>{{cite book |last1=De Macedo |first1=Joao |last2=Abreu |first2=Rui |last3=Pereira |first3=Rui |last4=Saraiva |first4=Joao |chapter=WebAssembly versus JavaScript: Energy and Runtime Performance |title=2022 International Conference on ICT for Sustainability (ICT4S) |date=June 2022 |pages=24–34 |doi=10.1109/ICT4S55073.2022.00014|hdl=1822/90291 |isbn=978-1-6654-8286-8 }}</ref>{{refn|group=note|A personal web page of 2024 reported a benchmark of a simple game application on a mobile phone found between 110% and 190% (i.e. faster) of native rates depending on the browser.<ref>{{cite web |last1=Turner |first1=Aaron |title=WebAssembly Is Fast: A Real-World Benchmark of WebAssembly vs. ES6 |url=https://medium.com/@torch2424/webassembly-is-fast-a-real-world-benchmark-of-webassembly-vs-es6-d85a23f8e193}}</ref>}}  

A 2021 study suggested that WebAssembly, in the versions they tested at that time, was much faster than JavaScript in certain cases with some browsers, such as running a complex function on a small file, e.g. processing a graphics file, but that JavaScript had some optimizations available, e.g. JIT, that WebAssembly did not.<ref>{{cite book |last1=Yan |first1=Yutian |last2=Tu |first2=Tengfei |last3=Zhao |first3=Lijian |last4=Zhou |first4=Yuchen |last5=Wang |first5=Weihang |title=Proceedings of the 21st ACM Internet Measurement Conference |chapter=Understanding the performance of webassembly applications |date=2 November 2021 |pages=533–549 |doi=10.1145/3487552.3487827 |isbn=978-1-4503-9129-0 |chapter-url=https://weihang-wang.github.io/slides/Yan-IMC21.pptx}}</ref>

In 2022, the [[Finance:Startup company|startup company]] named Zaplib summarized in a blog why they were shutting down.<ref name="zaplib"/> Their goal had been to significantly increase the performance of existing [[Web application|web apps]] by incrementally porting them to [[Rust (programming language)|Rust]]/Wasm. However, porting a customer's simulator from JavaScript only yielded a 5% improvement.<ref name="zaplib"/> Regarding [[Software:Figma|Figma]], they stated: "upon closer inspection it seems that their use of Wasm is more due to historical accidents—wanting to build in [[C++]] to hedge for their native app—than for critical performance needs. Figma files are processed in C++/Wasm, and this is likely a huge speedup, but most of Figma's performance magic is due to their [[Software:WebGL|WebGL]] renderer."<ref name="zaplib">{{cite web |title=Zaplib post-mortem |url=https://zaplib.com/docs/blog_post_mortem.html |website=zaplib.com |date=April 2022 |access-date=14 March 2024 |archive-date=21 March 2024 |archive-url=https://web.archive.org/web/20240321031950/https://zaplib.com/docs/blog_post_mortem.html |url-status=live }}</ref>

Benchmarking has revealed several other pain-points for WebAssembly, such as poor performance because of no direct access to the DOM,{{refn|group=note|"WebAssembly provides no access to the surrounding environment other than via the JavaScript API described in the JS API specification."<ref>{{cite web |title=WebAssembly Web API |url=https://webassembly.github.io/spec/web-api/index.html#security-considerations |website=webassembly.github.io |access-date=6 December 2024 |archive-date=9 December 2024 |archive-url=https://web.archive.org/web/20241209175823/https://webassembly.github.io/spec/web-api/index.html#security-considerations |url-status=live }}</ref>}} a problem which is being addressed.<ref>{{cite web |last1=Kambale |first1=Enoch |title=WebAssembly in 2024: Promises, Challenges, and the Road Ahead |url=https://blog.enkambale.com/webassembly-2024-state-of-wasm/ |website=blog.enkambale.com |access-date=6 December 2024 |language=en |archive-date=17 January 2025 |archive-url=https://web.archive.org/web/20250117145016/https://blog.enkambale.com/webassembly-2024-state-of-wasm/ |url-status=live }}</ref>

== WASI<span class="anchor" id="Beyond the Browser"></span> ==<!-- This section must eventually be merged into Implementations' sub section called like "host environments" as the WASI interface is (AFAIK) describes how some features must be provided by the host to the VM's executed .wasm programs.  -->

{{anchor|WASI}}WebAssembly System Interface (WASI) is a simple interface ([[Application binary interface|ABI]] and [[Application programming interface|API]]) designed by Mozilla, which is intended to be portable to any platform.<ref name="WASI">{{cite web |url=https://github.com/WebAssembly/WASI |title=WebAssembly System Interface Repo |work=[[GitHub]] / WebAssembly |date=10 February 2020 |access-date=15 May 2019 |archive-date=30 October 2022 |archive-url=https://web.archive.org/web/20221030175015/https://github.com/WebAssembly/WASI |url-status=live }}</ref> It provides [[POSIX]]-like features like file I/O constrained by [[Capability-based security|capability-based security]].<ref>{{cite web |title=Additional background on Capabilities |url=https://github.com/bytecodealliance/wasmtime/blob/master/docs/WASI-capabilities.md |website=GitHub |date=4 March 2022 |publisher=bytecodealliance |language=en |access-date=8 April 2020 |archive-date=24 February 2020 |archive-url=https://web.archive.org/web/20200224185640/https://github.com/bytecodealliance/wasmtime/blob/master/docs/WASI-capabilities.md |url-status=live }}</ref><ref>{{cite web |title=Standardizing WASI: A system interface to run WebAssembly outside the web – Mozilla Hacks - the Web developer blog |url=https://hacks.mozilla.org/2019/03/standardizing-wasi-a-webassembly-system-interface/ |website=Mozilla Hacks – the Web developer blog |access-date=9 April 2020 |archive-date=30 October 2022 |archive-url=https://web.archive.org/web/20221030175011/https://hacks.mozilla.org/2019/03/standardizing-wasi-a-webassembly-system-interface/ |url-status=live }}</ref> There are additional proposed ABI/APIs.<ref name="reference-sysroot">{{cite web |url=https://github.com/WebAssembly/reference-sysroot |title=reference-sysroot Repo |work=[[GitHub]] / WebAssembly |date=12 January 2020 |access-date=15 May 2019 |archive-date=21 August 2022 |archive-url=https://web.archive.org/web/20220821053218/https://github.com/WebAssembly/reference-sysroot |url-status=live }}</ref><ref name="wasm-c-api">{{cite web |url=https://github.com/WebAssembly/wasm-c-api |title=wasm-c-api Repo |work=[[GitHub]] / WebAssembly |date=3 February 2020 |access-date=15 May 2019 |archive-date=31 October 2022 |archive-url=https://web.archive.org/web/20221031072623/https://github.com/WebAssembly/wasm-c-api |url-status=live }}</ref>

WASI is influenced by [[Capsicum (Unix)#CloudABI|CloudABI]] and [[Capsicum (Unix)|Capsicum]].<ref>{{Citation |title=NuxiNL/cloudlibc |date=2024-12-06 |url=https://github.com/NuxiNL/cloudlibc |access-date=2025-04-01 |publisher=Nuxi |archive-date=1 April 2025 |archive-url=https://web.archive.org/web/20250401092414/https://github.com/NuxiNL/cloudlibc |url-status=live }}</ref>

{{interlanguage link|Solomon Hykes|fr}}, a co-founder of [[Software:Docker|Docker]], wrote in 2019, "If WASM+WASI existed in 2008, we wouldn't have needed to create Docker. That's how important it is. WebAssembly on the server is the future of computing."<ref>{{Cite web |last=Hykes |first=Solomon |date=March 27, 2019 |title=Solomon Hykes on X |url=https://x.com/solomonstre/status/1111004913222324225 |access-date=September 29, 2024 |website=[[Company:Twitter|Twitter]] |archive-date=31 May 2024 |archive-url=https://web.archive.org/web/20240531020223/https://x.com/solomonstre/status/1111004913222324225 |url-status=live }}</ref>

== Specification<span class="anchor" id="Features"></span>==

=== Host environment ===
The general standard provides core specifications for the JavaScript API and details on embedding.<ref name=":0" />

=== Virtual machine ===
Wasm code (binary code, i.e. bytecode) is intended to be run on a [[Software portability|portable]] virtual [[Stack machine|stack machine]] (VM).<ref name="stack machine" /> The VM is designed to be faster to parse and execute than JavaScript and to have compact code representation.<ref name="github.com" /> Any external functionality (like [[System call|syscalls]]) that may be expected by Wasm binary code is not stipulated by the standard. It rather provides a way to deliver interfacing via modules by the host environment that the VM runs in.<ref>{{Cite web|title=Portability - WebAssembly|url=https://webassembly.org/docs/portability/#assumptions-for-efficient-execution|access-date=2020-07-28|website=webassembly.org|archive-date=28 July 2020|archive-url=https://web.archive.org/web/20200728070343/https://webassembly.org/docs/portability/#assumptions-for-efficient-execution|url-status=live}}</ref><ref name=":1" />

=== Wasm program ===
A Wasm program is designed as a separate module containing collections of various Wasm-defined values and program type definitions. These are provided in either binary or textual format (see below) that have a common structure.<ref>{{Cite web|url=https://webassembly.github.io/spec/core/syntax/conventions.html|title=Conventions — WebAssembly 1.0|website=webassembly.github.io|access-date=12 November 2019|archive-date=6 May 2019|archive-url=https://web.archive.org/web/20190506193348/https://webassembly.github.io/spec/core/syntax/conventions.html|url-status=live}}</ref> Such a module may provide a start function that is executed upon instantiation of a wasm binary.

==== Instruction set ====
The core standard for the binary format of a Wasm program defines an [[Instruction set architecture|instruction set architecture]] (ISA) consisting of specific [[Opcode|binary encodings]] of types of operations which are executed by the VM (without specifying how exactly they must be executed).<ref>{{Cite web|url=https://webassembly.github.io/spec/core/intro/introduction.html?highlight=isa#scope|title=Introduction — WebAssembly 1.0|website=webassembly.github.io|access-date=17 May 2019|archive-date=2 June 2021|archive-url=https://web.archive.org/web/20210602213516/https://webassembly.github.io/spec/core/intro/introduction.html?highlight=isa#scope|url-status=live}}</ref> The list of instructions includes standard memory load/store instructions, numeric, parametric, [[Control flow|control of flow]] [[Instruction set architecture|instruction types]] and Wasm-specific variable instructions.<ref>{{Cite web|url=https://webassembly.github.io/spec/core/syntax/instructions.html|title=Instructions — WebAssembly 1.0|website=webassembly.github.io|access-date=12 November 2019|archive-date=21 October 2019|archive-url=https://web.archive.org/web/20191021072455/http://webassembly.github.io/spec/core/syntax/instructions.html|url-status=live}}</ref>

The number of opcodes used in the original standard (MVP) was a bit fewer than 200 of the 256 possible opcodes. Subsequent versions of WebAssembly pushed the number of opcodes a bit over 200. The WebAssembly SIMD proposal (for parallel processing) introduces an alternate opcode prefix (0xfd) for [[128-bit computing|128-bit]] SIMD. The concatenation of the SIMD prefix, plus an opcode that is valid after the SIMD prefix, forms a SIMD opcode. The SIMD opcodes bring an additional 236 instructions for the "minimum viable product" (MVP) SIMD capability (for a total of around 436 instructions).<ref>{{Cite web
          | url=https://github.com/WebAssembly/simd/pull/452
          | title=Final opcodes by tlively · Pull Request #452 · WebAssembly/simd · GitHub
          | last=Lively
          | first=Thomas
          | date=2021-02-19
          | orig-date=Pull Request opened on 2021-02-05
          | publisher=Bytecode Alliance
          | via=[[GitHub]]
          | access-date=2021-05-12
          | archive-date=30 October 2022
          | archive-url=https://web.archive.org/web/20221030175009/https://github.com/WebAssembly/simd/pull/452
          | url-status=live
          }}</ref><ref>{{Cite web
          | url=https://github.com/bytecodealliance/wasm-tools/blob/b5c3d98e40590512a3b12470ef358d5c7b983b15/crates/wast/src/ast/expr.rs
          | title=File wasm-tools/expr.rs at b5c3d98e40590512a3b12470ef358d5c7b983b15 · bytecodealliance/wasm-tools · GitHub
          | last=Delendik
          | first=Yury
          | date=2021-02-19
          | orig-date=SIMD changes committed on 2021-02-19
          | publisher=Bytecode Alliance
          | via=[[GitHub]]
          | access-date=2021-05-12
          | archive-date=22 May 2022
          | archive-url=https://web.archive.org/web/20220522082444/https://github.com/bytecodealliance/wasm-tools/blob/b5c3d98e40590512a3b12470ef358d5c7b983b15/crates/wast/src/ast/expr.rs
          | url-status=live
          }}</ref> Those instructions, the "finalized opcodes"<ref>{{Cite web|title=Update interpreter and text with finalized opcodes by ngzhian · Pull Request #486 · WebAssembly/simd|url=https://github.com/WebAssembly/simd/pull/486|access-date=2021-05-14|website=GitHub|language=en|archive-date=30 October 2022|archive-url=https://web.archive.org/web/20221030175015/https://github.com/WebAssembly/simd/pull/486|url-status=live}}</ref> are enabled by default across Google's V8 (in Google Chrome), the SpiderMonkey engine in Mozilla Firefox, and the JavaScriptCore engine in Apple's Safari<ref>{{Cite web|title=WebAssembly/simd|url=https://github.com/WebAssembly/simd|access-date=2021-05-14|website=GitHub|language=en|archive-date=10 May 2021|archive-url=https://web.archive.org/web/20210510003141/https://github.com/WebAssembly/simd|url-status=live}}</ref> and there are also some additional proposal for instructions for later "post SIMD MVP", and there is also a separate "relaxed-simd" proposal on the table.<ref>{{Citation|title=WebAssembly/relaxed-simd|date=2021-05-03|url=https://github.com/WebAssembly/relaxed-simd|publisher=WebAssembly|access-date=2021-05-14|archive-date=17 April 2022|archive-url=https://web.archive.org/web/20220417182748/https://github.com/WebAssembly/relaxed-simd|url-status=live}}</ref>

These SIMD opcodes are also portable and translate to native instruction sets like x64 and ARM. In contrast, neither Java's [[Java bytecode instruction listings|JVM]] nor CIL support SIMD, at their ''opcode level'', i.e. in the standard; both do have some parallel APIs which provide SIMD speedup. There is an extension for Java adding [[Intrinsic function|intrinsic]]s for x64 SIMD,<ref>{{Cite web|title=How we made the JVM 40x faster|url=https://astojanov.github.io/blog/2017/12/20/scala-simd.html|access-date=2021-02-17|website=astojanov.github.io|archive-date=26 December 2020|archive-url=https://web.archive.org/web/20201226051410/https://astojanov.github.io/blog/2017/12/20/scala-simd.html|url-status=live}}</ref> that isn't portable, i.e. not usable on ARM or smartphones. Smartphones can support SIMD by calling assembly code with SIMD, and C# has similar support.

==== Code representation ====
In March 2017, the WebAssembly Community Group reached consensus on the initial (MVP) binary format, JavaScript API, and reference interpreter.<ref name="Roadmap" /> It defines a WebAssembly binary format ({{code|.wasm}}), which is not designed to be used by humans, as well as a human-readable WebAssembly text format ({{code|.wat}}) that resembles a cross between S-expressions and traditional assembly languages.

The table below shows an example of a [[Factorial|factorial]] function written in [[C (programming language)|C]] and its corresponding WebAssembly code after compilation, shown both in {{mono|.wat}} text format (a human-readable textual representation of WebAssembly) and in {{mono|.wasm}} binary format (the raw [[Software:Bytecode|bytecode]], expressed below in [[Hexadecimal|hexadecimal]]), that is executed by a Web browser or run-time environment that supports WebAssembly.

{| class="wikitable"
|+C source code and corresponding WebAssembly
|-
!scope="col"|C source code
!scope="col"|WebAssembly {{mono|.wat}} text format
!scope="col"|WebAssembly {{mono|.wasm}} binary format
|- style="vertical-align:top"
|
<syntaxhighlight lang="c">
int factorial(int n) {
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n - 1);
    }
}
</syntaxhighlight>
||
<syntaxhighlight lang="wat">
(func (param i64) (result i64)
  local.get 0
  i64.eqz
  if (result i64)
      i64.const 1
  else
      local.get 0
      local.get 0
      i64.const 1
      i64.sub
      call 0
      i64.mul
  end)
</syntaxhighlight>
||
<syntaxhighlight lang="text">
00 61 73 6D 01 00 00 00
01 06 01 60 01 7E 01 7E
03 02 01 00
0A 17 01
15 00
20 00
50
04 7E
42 01
05
20 00
20 00
42 01
7D
10 00
7E
0B
0B
</syntaxhighlight>
|}

All integer constants are encoded using a space-efficient, variable-length [[LEB128]] encoding.<ref name=wasmint>{{cite web
 |url          = https://webassembly.github.io/spec/core/binary/values.html#integers
 |title        = WebAssembly Specification Release 1.0
 |access-date  = 13 January 2020
 |author       = WebAssembly Community Group
 |date         = January 2020
 |archive-date = 21 October 2019
 |archive-url  = https://web.archive.org/web/20191021070027/http://webassembly.github.io/spec/core/binary/values.html#integers
 |url-status   = live
}}</ref>

The WebAssembly text format is more canonically written in a folded format using [[S-expression]]s. For instructions and expressions, this format is purely [[Syntactic sugar|syntactic sugar]] and has no behavioral differences with the linear format.<ref name="Folded Instructions"/> Through {{code|wasm2wat}}, the code above decompiles to:

<syntaxhighlight lang="wat">
(module
  (type $t0 (func (param i64) (result i64)))
  (func $f0 (type $t0) (param $p0 i64) (result i64)
    (if $I0 (result i64) ;; $I0 is an unused label name
      (i64.eqz
        (local.get $p0)) ;; the name $p0 is the same as 0 here
      (then
        (i64.const 1))
      (else
        (i64.mul
          (local.get $p0)
          (call $f0      ;; the name $f0 is the same as 0 here
            (i64.sub
              (local.get $p0)
              (i64.const 1))))))))
</syntaxhighlight>

A module is implicitly generated by the compiler. The function is referenced by an entry of the type table in the binary, hence a type section and the {{code|type}} emitted by the decompiler.<ref>{{cite web |title=Modules (Binary) |url=https://webassembly.github.io/spec/core/syntax/modules.html |website=WebAssembly 1.0 |access-date=9 April 2020 |archive-date=30 October 2022 |archive-url=https://web.archive.org/web/20221030175009/https://webassembly.github.io/spec/core/syntax/modules.html |url-status=live }}</ref> The compiler and decompiler can be accessed online.<ref>{{cite web |title=WebAssembly Binary Toolkit (wabt) demos |url=https://webassembly.github.io/wabt/demo/ |website=webassembly.github.io |access-date=9 April 2020 |archive-date=30 October 2022 |archive-url=https://web.archive.org/web/20221030175011/https://webassembly.github.io/wabt/demo/ |url-status=live }}</ref>

== See also ==
* [[Architecture Neutral Distribution Format]] (ANDF)
* [[UNCOL]]
* [[Java bytecode]]
* [[Common Language Runtime]]
* [[Software:LLVM|LLVM]]
* [[Compiler|Compilation]]
* [[Software portability]]

== Notes ==
{{reflist|group=note}}

== References ==
{{reflist|30em|refs=
<ref name="techcrunch2015">{{Cite news|url=https://techcrunch.com/2015/06/17/google-microsoft-mozilla-and-others-team-up-to-launch-webassembly-a-new-binary-format-for-the-web/|title=Google, Microsoft, Mozilla And Others Team Up To Launch WebAssembly, A New Binary Format For The Web|last=Lardinois|first=Frederic|date=17 June 2015|work=TechCrunch|access-date=24 December 2017|language=en|archive-date=17 January 2018|archive-url=https://web.archive.org/web/20180117072109/https://techcrunch.com/2015/06/17/google-microsoft-mozilla-and-others-team-up-to-launch-webassembly-a-new-binary-format-for-the-web/|url-status=live}}</ref>

<ref name="ars">{{cite web |first=Peter |last=Bright |url=https://arstechnica.com/information-technology/2015/06/the-web-is-getting-its-bytecode-webassembly/ |title=The Web is getting its bytecode: WebAssembly |work=[[Ars Technica]] |publisher=Condé Nast |date=18 June 2015 |access-date=15 June 2017 |archive-date=11 April 2019 |archive-url=https://web.archive.org/web/20190411190121/https://arstechnica.com/information-technology/2015/06/the-web-is-getting-its-bytecode-webassembly/ |url-status=live }}</ref>

<ref name="bytecode">{{Cite news|url=https://blog.mozilla.org/press/2019/11/new-bytecode-alliance-brings-the-security-ubiquity-and-interoperability-of-the-web-to-the-world-of-pervasive-computing/|title=New Bytecode Alliance Brings the Security, Ubiquity, and Interoperability of the Web to the World of Pervasive Computing|date=12 November 2019|work=Mozilla|access-date=27 May 2019|language=en|archive-date=10 December 2019|archive-url=https://web.archive.org/web/20191210040548/https://blog.mozilla.org/press/2019/11/new-bytecode-alliance-brings-the-security-ubiquity-and-interoperability-of-the-web-to-the-world-of-pervasive-computing/|url-status=live}}</ref>

<ref name=AcceleratingWeb>{{cite web|url=https://zendev.com/2018/06/26/webassembly-accelerating-future-web-development.html |title=How WebAssembly is Accelerating the Future of Web Development |last=Ball | first=Kevin |date=26 June 2018 |access-date=22 October 2018 |archive-url=https://web.archive.org/web/20190212141715/https://zendev.com/2018/06/26/webassembly-accelerating-future-web-development.html |archive-date=12 February 2019}}</ref>

<ref name=Implementations>{{cite web |url=https://github.com/appcypher/awesome-wasm-langs |title=Awesome WebAssembly Languages |website=[[GitHub]] |date=26 June 2018 |access-date=15 February 2022 |archive-date=12 February 2019 |archive-url=https://web.archive.org/web/20190212133939/https://github.com/appcypher/awesome-wasm-langs |url-status=live }}</ref>

<ref name="stack machine">{{cite web|url=https://github.com/WebAssembly/design/blob/main/Rationale.md#why-a-stack-machine|title=Design Rationale|date=1 October 2016|work=[[GitHub]] / WebAssembly / design|access-date=25 September 2022|archive-date=25 September 2022|archive-url=https://web.archive.org/web/20220925175844/https://github.com/WebAssembly/design/blob/main/Rationale.md#why-a-stack-machine|url-status=live}}</ref>

<ref name="github.com">{{cite web|url=https://github.com/WebAssembly/design/blob/main/HighLevelGoals.md|title=WebAssembly High-Level Goals|date=11 December 2015|work=[[GitHub]] / WebAssembly / design|access-date=25 September 2022|archive-date=25 September 2022|archive-url=https://web.archive.org/web/20220925175845/https://github.com/WebAssembly/design/blob/main/HighLevelGoals.md|url-status=live}}</ref>

<ref name="PNaCl">{{Cite web|url=https://www.infoq.com/news/2017/05/pnacl-webassembly-google|title=Google Is to Remove Support for PNaCl|last=Avram|first=Abel|date=31 May 2017|website=InfoQ|access-date=22 December 2017|archive-date=23 December 2017|archive-url=https://web.archive.org/web/20171223102925/https://www.infoq.com/news/2017/05/pnacl-webassembly-google|url-status=live}}</ref>

<ref name="initial implementation">{{cite web|url=https://www.2ality.com/2015/06/web-assembly.html|title=WebAssembly: a binary format for the web|work=②ality&nbsp;– JavaScript and more|date=18 June 2015|access-date=25 July 2019|archive-date=6 November 2023|archive-url=https://web.archive.org/web/20231106132841/https://2ality.com/2015/06/web-assembly.html|url-status=live}}</ref>

<ref name="Launch bug">{{Cite web|url=https://github.com/WebAssembly/design/issues/150|title=Launch bug|date=11 June 2015|website=[[GitHub]] / WebAssembly / design|access-date=21 March 2016|archive-date=21 November 2021|archive-url=https://web.archive.org/web/20211121074724/https://github.com/WebAssembly/design/issues/150|url-status=live}}</ref>

<ref name="Unity in Firefox">{{Cite web|url=https://hacks.mozilla.org/2016/03/a-webassembly-milestone/|title=A WebAssembly Milestone: Experimental Support in Multiple Browsers|last=Wagner|first=Luke|date=14 March 2016|website=Mozilla Hacks|access-date=21 March 2016|archive-date=11 August 2017|archive-url=https://web.archive.org/web/20170811143725/https://hacks.mozilla.org/2016/03/a-webassembly-milestone/|url-status=live}}</ref>

<ref name="V8 blog">{{Cite web|url=https://v8project.blogspot.com/2016/03/experimental-support-for-webassembly.html|title=Experimental support for WebAssembly in V8|last=Thompson|first=Seth|date=15 March 2016|website=V8 Blog|access-date=25 July 2019|archive-date=9 February 2018|archive-url=https://web.archive.org/web/20180209085419/https://v8project.blogspot.com/2016/03/experimental-support-for-webassembly.html|url-status=live}}</ref>

<ref name="Edge">{{Cite web|url=https://blogs.windows.com/msedgedev/2016/03/15/previewing-webassembly-experiments/|title=Previewing WebAssembly experiments in Microsoft Edge|last=Zhu|first=Limin|date=15 March 2016|website=Microsoft Edge dev blog|access-date=21 March 2016|archive-date=18 August 2021|archive-url=https://web.archive.org/web/20210818082723/https://blogs.windows.com/msedgedev/2016/03/15/previewing-webassembly-experiments/|url-status=live}}</ref>

<ref name="MVP">{{Cite news|url=https://www.infoworld.com/article/3176681/|title=WebAssembly is now ready for browsers to use|last=Krill|first=Paul|date=6 March 2017|work=InfoWorld|access-date=23 December 2017|language=en|archive-date=1 April 2020|archive-url=https://web.archive.org/web/20200401050237/https://www.infoworld.com/article/3176681/webassembly-is-now-ready-for-browsers-to-use.html|url-status=live}}</ref>

<ref name="canIuse.com">{{Cite web |title=WebAssembly {{!}} Can I use... Support tables for HTML5, CSS3, etc |url=https://caniuse.com/wasm |access-date=2024-03-01 |website=canIuse.com |archive-date=13 November 2021 |archive-url=https://web.archive.org/web/20211113062453/https://caniuse.com/wasm |url-status=live }}</ref>

<ref name="in browsers">{{Cite web|url=https://blog.mozilla.org/blog/2017/11/13/webassembly-in-browsers/|title=WebAssembly support now shipping in all major browsers|website=The Mozilla Blog|language=en-US|access-date=21 November 2017|archive-date=31 October 2019|archive-url=https://web.archive.org/web/20191031205718/https://blog.mozilla.org/blog/2017/11/13/webassembly-in-browsers/|url-status=live}}</ref>

<ref name="Edge16">{{Cite web|url=https://blogs.windows.com/msedgedev/2017/10/31/optimizations-webassembly-sharedarraybuffer-atomics-edgehtml-16/|title=Introducing new JavaScript optimizations, WebAssembly, SharedArrayBuffer, and Atomics in EdgeHTML 16|website=Microsoft Edge Dev Blog|language=en-US|access-date=21 November 2017|date=31 October 2017|archive-date=15 November 2017|archive-url=https://web.archive.org/web/20171115015019/https://blogs.windows.com/msedgedev/2017/10/31/optimizations-webassembly-sharedarraybuffer-atomics-edgehtml-16/|url-status=live}}</ref>

<!--<ref name="ars2015">{{Cite news|url=https://arstechnica.com/information-technology/2015/06/the-web-is-getting-its-bytecode-webassembly/|title=The Web is getting its bytecode: WebAssembly|last=Bright|first=Peter|date=18 June 2015|work=Ars Technica|access-date=23 December 2017|language=en-us}}</ref>  -->

<ref name="Rust">{{Cite news|url=https://www.infoworld.com/article/3239129/|title=Direct WebAssembly compilation comes to Rust language|last=Krill|first=Paul|date=29 November 2017|work=InfoWorld|access-date=24 December 2017|language=en|archive-date=1 April 2020|archive-url=https://web.archive.org/web/20200401050237/https://www.infoworld.com/article/3239129/rust-language-gets-direct-webassembly-compilation.html|url-status=live}}</ref>

<!-- <ref name="next">{{Cite news|url=https://www.techworld.com.au/article/629123/|title=What's next for WebAssembly: GC, threads, debugging|last=Krill|first=Paul|date=26 October 2017|work=TechWorld|access-date=24 December 2017}}</ref> -->

<ref name="Roadmap">{{Cite web|url=https://webassembly.org/roadmap/|title=Roadmap|website=WebAssembly|date=March 2017|access-date=25 July 2019|archive-date=7 December 2021|archive-url=https://web.archive.org/web/20211207095013/https://webassembly.org/roadmap/|url-status=live}}</ref>

<ref name="W3C-WD2018">{{cite web|url=https://www.w3.org/blog/news/archives/6838|title=WebAssembly First Public Working Drafts|publisher=W3C|date=15 February 2018|access-date=20 April 2018|archive-date=16 July 2021|archive-url=https://web.archive.org/web/20210716150641/https://www.w3.org/blog/news/archives/6838|url-status=live}}</ref>
<ref name="W3C-CSWD2018">{{cite web|url=https://www.w3.org/TR/2018/WD-wasm-core-1-20180215/|title=WebAssembly Core Specification|publisher=W3C|date=15 February 2018|access-date=20 April 2018|archive-date=8 March 2021|archive-url=https://web.archive.org/web/20210308171158/https://www.w3.org/TR/2018/WD-wasm-core-1-20180215/|url-status=live}}</ref>
<ref name="W3C-JIWD2018">{{cite web|url=https://www.w3.org/TR/2018/WD-wasm-js-api-1-20180215/|title=WebAssembly JavaScript Interface|publisher=W3C|date=15 February 2018|access-date=20 April 2018|archive-date=30 November 2020|archive-url=https://web.archive.org/web/20201130203818/https://www.w3.org/TR/2018/WD-wasm-js-api-1-20180215/|url-status=live}}</ref>
<ref name="W3C-WAWD2018">{{cite web|url=https://www.w3.org/TR/2018/WD-wasm-web-api-1-20180215/|title=WebAssembly Web API|publisher=W3C|date=15 February 2018|access-date=20 April 2018|archive-date=19 April 2021|archive-url=https://web.archive.org/web/20210419005848/https://www.w3.org/TR/2018/WD-wasm-web-api-1-20180215/|url-status=live}}</ref>

<ref name="Folded Instructions">{{cite web|url=https://webassembly.github.io/spec/core/text/instructions.html#folded-instructions|title=Folded instructions|work=[[GitHub]]|access-date=18 June 2018|archive-date=12 July 2018|archive-url=https://web.archive.org/web/20180712214813/http://webassembly.github.io/spec/core/text/instructions.html#folded-instructions|url-status=live}} / WebAssembly / spec</ref>
}}

{{Free-content attribution|
|title= Text Format
|author = jfbastien; rossberg-chromium; kripken; titzer; s3ththompson; sunfishcode; lukewagner; flagxor; enricobacis; c3d; binji; andrewosh
|publisher = GitHub
|source= WebAssembly/design
|documentURL= https://github.com/WebAssembly/design/blob/main/TextFormat.md
|license statement URL= https://github.com/WebAssembly/design/blob/main/LICENSE
|license= Apache License 2.0
}}

== External links ==
* {{Official website}}
* {{GitHub|WebAssembly}}, hosts Design Documents
* [https://www.w3.org/community/webassembly/ W3C Community Group] {{Webarchive|url=https://web.archive.org/web/20150618022149/https://www.w3.org/community/webassembly/ |date=18 June 2015 }}
* [https://webassembly.github.io/spec/core/ WebAssembly Specification] {{Webarchive|url=https://web.archive.org/web/20220922054129/https://webassembly.github.io/spec/core/ |date=22 September 2022 }}
* {{Cite web |url=https://developer.mozilla.org/en-US/docs/WebAssembly |title=WebAssembly |website=MDN Web Docs |date=16 April 2024 |language=en-US |access-date=14 February 2018 |archive-date=13 May 2022 |archive-url=https://web.archive.org/web/20220513193623/https://developer.mozilla.org/en-US/docs/WebAssembly |url-status=live }} Has info on browser compatibility and specifications (WebAssembly JavaScript API)

{{W3C Standards}}
{{Web browsers|fsp}}
{{Web interfaces}}
{{JavaScript}}

[[Category:Assembly languages]]
[[Category:World Wide Web Consortium standards]]
[[Category:Web programming]]
<!-- Hidden categories below -->

{{Sourceattribution|WebAssembly}}