Abstract
WebAssembly (Wasm) is a compact, well-specified bytecode format that offers a portable compilation target with near-native execution speed. The bytecode format was specifically designed to be fast to parse, validate, and compile, positioning itself as a portable alternative to native code. It was pointedly not designed to be interpreted directly. Instead, design considerations at the time focused on competing with native code, utilizing optimizing compilers as the primary execution tier. Yet, in JIT scenarios, compilation time and memory consumption critically impact application startup, leading many Wasm engines to later deploy faster single-pass (baseline) compilers. Though faster, baseline compilers still take time and waste code space for infrequently executed code. A typical interpreter being infeasible, some engines resort to compiling Wasm not to machine code, but to a more compact, but easy to interpret format. This still takes time and wastes memory. Instead, we introduce in this article a fast in-place interpreter for WebAssembly, where no rewrite and no separate format is necessary. Our evaluation shows that in-place interpretation of Wasm code is space-efficient and fast, achieving performance on-par with interpreting a custom-designed internal format. This fills a hole in the execution tier space for Wasm, allowing for even faster startup and lower memory footprint than previous engine configurations.
- 1998. Hotspot internals: interpreter. https://openjdk.java.net/groups/hotspot/docs/RuntimeOverview.html (Accessed 2022-4-07)
Google Scholar
- 2015. lli - directly execute programs from LLVM bitcode. https://llvm.org/docs/CommandGuide/lli.html (Accessed 2022-4-12)
Google Scholar
- 2018. https://v8.dev/blog/liftoff (Accessed 2022-4-07)
Google Scholar
- 2018. TurboFan: V8’s Optimizing Compiler. https://v8.dev/docs/turbofan (Accessed 2021-07-29)
Google Scholar
- 2018. WAVM: a non-browser WebAssembly virtual machine. https://github.com/WAVM/WAVM (Accessed 2022-1-10)
Google Scholar
- 2019. A New Bytecode Format for JavaScriptCore. https://webkit.org/blog/9329/a-new-bytecode-format-for-javascriptcore/ (Accessed 2022-04-07)
Google Scholar
- 2020. The edge of the multi-cloud. https://www.fastly.com/cassets/6pk8mg3yh2ee/79dsHLTEfYIMgUwVVllaa4/5e5330572b8f317f72e16696256d8138/WhitePaper-Multi-Cloud.pdf (Accessed 2021-07-06)
Google Scholar
- 2020. Wasm3: The fastest WebAssembly interpreter, and the most universal runtime.. https://github.com/wasm3/wasm3 (Accessed 2021-08-11)
Google Scholar
- 2021. A fast WebAssembly Interpreter design in WASM-Micro-Runtime. https://www.intel.com/content/www/us/en/developer/articles/technical/webassembly-interpreter-design-wasm-micro-runtime.html (Accessed 2022-09-19)
Google Scholar
- 2021. JavaScriptCore, the built-in JavaScript engine for WebKit. https://trac.webkit.org/wiki/JavaScriptCore (Accessed 2021-07-29)
Google Scholar
- 2021. SpiderMonkey: Mozilla’s JavaScript and WebAssembly engine. https://spidermonkey.dev (Accessed 2021-07-29)
Google Scholar
- 2021. V8 Development Site. https://v8.dev (Accessed 2021-07-29)
Google Scholar
- 2021. Wasmer: A Fast and Secure WebAssembly Runtime. https://github.com/wasmerio/wasmer (Accessed 2021-07-06)
Google Scholar
- 2021. Wasmtime: a standalone runtime for WebAssembly. https://github.com/bytecodealliance/wasmtime (Accessed 2021-08-11)
Google Scholar
- 2022. Ignition: a fast low-level interpreter. https://v8.dev/docs/ignition (Accessed 2022-04-11)
Google Scholar
- 2022. Labels as Values (GNU Compiler Collection). https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html (Accessed 2022-04-11)
Google Scholar
- 2022. LEB128. https://en.wikipedia.org/wiki/LEB128 (Accessed 2022-04-11)
Google Scholar
- 2022. WebAssembly Micro Runtime (WAMR). https://github.com/bytecodealliance/wasm-micro-runtime (Accessed 2022-04-11)
Google Scholar
- Nada Amin and Tiark Rompf. 2017. Collapsing Towers of Interpreters. Proc. ACM Program. Lang., 2, POPL (2017), Article 52, dec, 33 pages. https://doi.org/10.1145/3158140
Google Scholar
Digital Library
- Gergö Barany. 2014. Python Interpreter Performance Deconstructed. In Proceedings of the Workshop on Dynamic Languages and Applications (Dyla’14). Association for Computing Machinery, New York, NY, USA. 1–9. isbn:9781450329163 https://doi.org/10.1145/2617548.2617552
Google Scholar
Digital Library
- James R. Bell. 1973. Threaded Code. Commun. ACM, 16, 6 (1973), jun, 370–372. issn:0001-0782 https://doi.org/10.1145/362248.362270
Google Scholar
Digital Library
- Carl Friedrich Bolz, Antonio Cuni, Maciej Fijalkowski, and Armin Rigo. 2009. Tracing the Meta-Level: PyPy’s Tracing JIT Compiler. In Proceedings of the 4th Workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages and Programming Systems (ICOOOLPS ’09). Association for Computing Machinery, New York, NY, USA. 18–25. isbn:9781605585413 https://doi.org/10.1145/1565824.1565827
Google Scholar
Digital Library
- Stefan Brunthaler. 2010. Efficient Interpretation Using Quickening. In Proceedings of the 6th Symposium on Dynamic Languages (DLS ’10). Association for Computing Machinery, New York, NY, USA. 1–14. isbn:9781450304054 https://doi.org/10.1145/1869631.1869633
Google Scholar
Digital Library
- Kevin Casey, M. Anton Ertl, and David Gregg. 2007. Optimizing Indirect Branch Prediction Accuracy in Virtual Machine Interpreters. ACM Trans. Program. Lang. Syst., 29, 6 (2007), oct, 37–es. issn:0164-0925 https://doi.org/10.1145/1286821.1286828
Google Scholar
Digital Library
- Kevin Casey, David Gregg, and M. Anton Ertl. 2005. Tiger – an Interpreter Generation Tool. In Proceedings of the 14th International Conference on Compiler Construction (CC’05). Springer-Verlag, Berlin, Heidelberg. 246–249. isbn:3540254110 https://doi.org/10.1007/978-3-540-31985-6_18
Google Scholar
Digital Library
- Po-Yung Chang, Eric Hao, and Yale N Patt. 1997. Target prediction for indirect jumps. ACM SIGARCH Computer Architecture News, 25, 2 (1997), 274–283.
Google Scholar
Digital Library
- Charlie Curtsinger and Emery D. Berger. 2013. STABILIZER: Statistically Sound Performance Evaluation. In Proceedings of the Eighteenth International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS ’13). Association for Computing Machinery, New York, NY, USA. 219–228. isbn:9781450318709 https://doi.org/10.1145/2451116.2451141
Google Scholar
Digital Library
- Brian Davis, Andrew Beatty, Kevin Casey, David Gregg, and John Waldron. 2003. The Case for Virtual Register Machines. In Proceedings of the 2003 Workshop on Interpreters, Virtual Machines and Emulators (IVME ’03). Association for Computing Machinery, New York, NY, USA. 41–49. isbn:1581136552 https://doi.org/10.1145/858570.858575
Google Scholar
Digital Library
- Alan Demers, Mark Weiser, Barry Hayes, Hans Boehm, Daniel Bobrow, and Scott Shenker. 1989. Combining Generational and Conservative Garbage Collection: Framework and Implementations. In Proceedings of the 17th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’90). Association for Computing Machinery, New York, NY, USA. 261–269. isbn:0897913434 https://doi.org/10.1145/96709.96735
Google Scholar
Digital Library
- Robert B. K. Dewar. 1975. Indirect Threaded Code. Commun. ACM, 18, 6 (1975), jun, 330–331. issn:0001-0782 https://doi.org/10.1145/360825.360849
Google Scholar
Digital Library
- Amer Diwan, Eliot Moss, and Richard Hudson. 1992. Compiler Support for Garbage Collection in a Statically Typed Language. In Proceedings of the ACM SIGPLAN 1992 Conference on Programming Language Design and Implementation (PLDI ’92). Association for Computing Machinery, New York, NY, USA. 273–282. isbn:0897914759 https://doi.org/10.1145/143095.143140
Google Scholar
Digital Library
- M. Anton Ertl and David Gregg. 2004. Combining Stack Caching with Dynamic Superinstructions. In Proceedings of the 2004 Workshop on Interpreters, Virtual Machines and Emulators (IVME ’04). Association for Computing Machinery, New York, NY, USA. 7–14. isbn:1581139098 https://doi.org/10.1145/1059579.1059583
Google Scholar
Digital Library
- M. Anton Ertl and David Gregg. 2004. Combining Stack Caching with Dynamic Superinstructions. In Proceedings of the 2004 Workshop on Interpreters, Virtual Machines and Emulators (IVME ’04). Association for Computing Machinery, New York, NY, USA. 7–14. isbn:1581139098 https://doi.org/10.1145/1059579.1059583
Google Scholar
Digital Library
- M. Anton Ertl, David Gregg, Andreas Krall, and Bernd Paysan. 2002. Vmgen: A Generator of Efficient Virtual Machine Interpreters. Softw. Pract. Exper., 32, 3 (2002), mar, 265–294. issn:0038-0644 https://doi.org/10.1002/spe.434
Google Scholar
Digital Library
- Y. Futamura. 1983. Partial computation of programs.. Lecture Notes in Computer Science, 147 (1983).
Google Scholar
Cross Ref
- Andreas Gal, Brendan Eich, Mike Shaver, David Anderson, David Mandelin, Mohammad R. Haghighat, Blake Kaplan, Graydon Hoare, Boris Zbarsky, Jason Orendorff, Jesse Ruderman, Edwin W. Smith, Rick Reitmaier, Michael Bebenita, Mason Chang, and Michael Franz. 2009. Trace-Based Just-in-Time Type Specialization for Dynamic Languages. In Proceedings of the 30th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’09). Association for Computing Machinery, New York, NY, USA. 465–478. isbn:9781605583921 https://doi.org/10.1145/1542476.1542528
Google Scholar
Digital Library
- Robbert Gurdeep Singh and Christophe Scholliers. 2019. WARDuino: A Dynamic WebAssembly Virtual Machine for Programming Microcontrollers. In Proceedings of the 16th ACM SIGPLAN International Conference on Managed Programming Languages and Runtimes (MPLR 2019). Association for Computing Machinery, New York, NY, USA. 27–36. isbn:9781450369770 https://doi.org/10.1145/3357390.3361029
Google Scholar
Digital Library
- Andreas Haas, Andreas Rossberg, Derek L. Schuff, Ben L. Titzer, Michael Holman, Dan Gohman, Luke Wagner, Alon Zakai, and JF Bastien. 2017. Bringing the Web up to Speed with WebAssembly. In Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). Association for Computing Machinery, New York, NY, USA. 185–200. isbn:9781450349888 https://doi.org/10.1145/3062341.3062363
Google Scholar
Digital Library
- Xiaowen Hu, David Zhao, Herbert Jordan, and Bernhard Scholz. 2021. An Efficient Interpreter for Datalog by De-Specializing Relations. PLDI 2021. Association for Computing Machinery, New York, NY, USA. 681–695. isbn:9781450383912 https://doi.org/10.1145/3453483.3454070
Google Scholar
Digital Library
- Tomas Kalibera, Petr Maj, Floreal Morandat, and Jan Vitek. 2014. A Fast Abstract Syntax Tree Interpreter for R. In Proceedings of the 10th ACM SIGPLAN/SIGOPS International Conference on Virtual Execution Environments (VEE ’14). Association for Computing Machinery, New York, NY, USA. 89–102. isbn:9781450327640 https://doi.org/10.1145/2576195.2576205
Google Scholar
Digital Library
- Takafumi Kataoka, Tomoharu Ugawa, and Hideya Iwasaki. 2018. A Framework for Constructing Javascript Virtual Machines with Customized Datatype Representations. In Proceedings of the 33rd Annual ACM Symposium on Applied Computing (SAC ’18). Association for Computing Machinery, New York, NY, USA. 1238–1247. isbn:9781450351911 https://doi.org/10.1145/3167132.3167266
Google Scholar
Digital Library
- Channoh Kim, Sungmin Kim, Hyeon Gyu Cho, Dooyoung Kim, Jaehyeok Kim, Young H. Oh, Hakbeom Jang, and Jae W. Lee. 2016. Short-Circuit Dispatch: Accelerating Virtual Machine Interpreters on Embedded Processors. In 2016 ACM/IEEE 43rd Annual International Symposium on Computer Architecture (ISCA). 291–303. https://doi.org/10.1109/ISCA.2016.34
Google Scholar
Digital Library
- Borui Li, Hongchang Fan, Yi Gao, and Wei Dong. 2021. ThingSpire OS: A WebAssembly-Based IoT Operating System for Cloud-Edge Integration. In Proceedings of the 19th Annual International Conference on Mobile Systems, Applications, and Services (MobiSys ’21). Association for Computing Machinery, New York, NY, USA. 487–488. isbn:9781450384438 https://doi.org/10.1145/3458864.3466910
Google Scholar
Digital Library
- John McCarthy. 1960. Recursive Functions of Symbolic Expressions and Their Computation by Machine, Part I. Commun. ACM, 3, 4 (1960), apr, 184–195. issn:0001-0782 https://doi.org/10.1145/367177.367199
Google Scholar
Digital Library
- Microsoft. 2021. ChakraCore: a JavaScript engine with a C API. https://github.com/chakra-core/ChakraCore (Accessed 2021-07-29)
Google Scholar
- Todd Mytkowicz, Amer Diwan, Matthias Hauswirth, and Peter F. Sweeney. 2009. Producing Wrong Data without Doing Anything Obviously Wrong!. In Proceedings of the 14th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS XIV). Association for Computing Machinery, New York, NY, USA. 265–276. isbn:9781605584065 https://doi.org/10.1145/1508244.1508275
Google Scholar
Digital Library
- Manuel Nieke, Lennart Almstedt, and Rüdiger Kapitza. 2021. Edgedancer: Secure Mobile WebAssembly Services on the Edge. In Proceedings of the 4th International Workshop on Edge Systems, Analytics and Networking (EdgeSys ’21). Association for Computing Machinery, New York, NY, USA. 13–18. isbn:9781450382915 https://doi.org/10.1145/3434770.3459731
Google Scholar
Digital Library
- Fabio Niephaus, Tim Felgentreff, and Robert Hirschfeld. 2018. GraalSqueak: A Fast Smalltalk Bytecode Interpreter Written in an AST Interpreter Framework. In Proceedings of the 13th Workshop on Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS ’18). Association for Computing Machinery, New York, NY, USA. 30–35. isbn:9781450358040 https://doi.org/10.1145/3242947.3242948
Google Scholar
Digital Library
- Mohammed Nurul-Hoque and Khaled A. Harras. 2021. Nomad: Cross-Platform Computational Offloading and Migration in Femtoclouds Using WebAssembly. In 2021 IEEE International Conference on Cloud Engineering (IC2E). 168–178. https://doi.org/10.1109/IC2E52221.2021.00032
Google Scholar
Cross Ref
- Kazunori Ogata, Hideaki Komatsu, and Toshio Nakatani. 2002. Bytecode Fetch Optimization for a Java Interpreter. In Proceedings of the 10th International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS X). Association for Computing Machinery, New York, NY, USA. 58–67. isbn:1581135742 https://doi.org/10.1145/605397.605404
Google Scholar
Digital Library
- Jens Palsberg. 2014. From Java to Mips in Four Nifty Steps. http://web.cs.ucla.edu/classes/spring11/cs132/kannan/index.html (Accessed 2022-4-07)
Google Scholar
- Jinzhan Peng, Gansha Wu, and Guei-Yuan Lueh. 2004. Code Sharing among States for Stack-Caching Interpreter. In Proceedings of the 2004 Workshop on Interpreters, Virtual Machines and Emulators (IVME ’04). Association for Computing Machinery, New York, NY, USA. 15–22. isbn:1581139098 https://doi.org/10.1145/1059579.1059584
Google Scholar
Digital Library
- Ian Piumarta and Fabio Riccardi. 1998. Optimizing Direct Threaded Code by Selective Inlining. In Proceedings of the ACM SIGPLAN 1998 Conference on Programming Language Design and Implementation (PLDI ’98). Association for Computing Machinery, New York, NY, USA. 291–300. isbn:0897919874 https://doi.org/10.1145/277650.277743
Google Scholar
Digital Library
- Filip Pizlo. 2016. Introducing the B3 JIT Compiler. https://webkit.org/blog/5852/introducing-the-b3-jit-compiler/ (Accessed 2022-4-12)
Google Scholar
- Todd A. Proebsting. 1995. Optimizing an ANSI C Interpreter with Superoperators. In Proceedings of the 22nd ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’95). Association for Computing Machinery, New York, NY, USA. 322–332. isbn:0897916921 https://doi.org/10.1145/199448.199526
Google Scholar
Digital Library
- Gregory B. Prokopski and Clark Verbrugge. 2008. Analyzing the Performance of Code-Copying Virtual Machines. SIGPLAN Not., 43, 10 (2008), oct, 403–422. issn:0362-1340 https://doi.org/10.1145/1449955.1449796
Google Scholar
Digital Library
- Erven Rohou, Bharath Narasimha Swamy, and André Seznec. 2015. Branch prediction and the performance of interpreters — Don’t trust folklore. In 2015 IEEE/ACM International Symposium on Code Generation and Optimization (CGO). 103–114. https://doi.org/10.1109/CGO.2015.7054191
Google Scholar
Cross Ref
- Gülfem Savrun-Yeniçeri, Wei Zhang, Huahan Zhang, Eric Seckler, Chen Li, Stefan Brunthaler, Per Larsen, and Michael Franz. 2014. Efficient Hosted Interpreters on the JVM. ACM Trans. Archit. Code Optim., 11, 1 (2014), Article 9, feb, 24 pages. issn:1544-3566 https://doi.org/10.1145/2532642
Google Scholar
Digital Library
- Yunhe Shi, David Gregg, Andrew Beatty, and M. Anton Ertl. 2005. Virtual Machine Showdown: Stack versus Registers. In Proceedings of the 1st ACM/USENIX International Conference on Virtual Execution Environments (VEE ’05). Association for Computing Machinery, New York, NY, USA. 153–163. isbn:1595930477 https://doi.org/10.1145/1064979.1065001
Google Scholar
Digital Library
- Ben L. Titzer. 2013. Harmonizing Classes, Functions, Tuples, and Type Parameters in Virgil III. In Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI ’13). Association for Computing Machinery, New York, NY, USA. 85–94. isbn:9781450320146 https://doi.org/10.1145/2491956.2491962
Google Scholar
Digital Library
- Ben L. Titzer. 2021. Wizard, An advanced WebAssembly Engine for Research. https://github.com/titzer/wizard-engine (Accessed 2021-07-29)
Google Scholar
- Ben L. Titzer. 2022. Oopsla 2022 Artifact. https://github.com/titzer/oopsla22-artifact (Accessed 2021-10-1)
Google Scholar
- Ben L. Titzer. 2022. OOPSLA 2022 Artifact for "A Fast in-place Interpreter for WebAssembly". https://doi.org/10.5281/zenodo.7093079
Google Scholar
Digital Library
- Ben L. Titzer and Jens Palsberg. 2005. Nonintrusive Precision Instrumentation of Microcontroller Software. In Proceedings of the 2005 ACM SIGPLAN/SIGBED Conference on Languages, Compilers, and Tools for Embedded Systems (LCTES ’05). Association for Computing Machinery, New York, NY, USA. 59–68. isbn:1595930183 https://doi.org/10.1145/1065910.1065919
Google Scholar
Digital Library
- Kevin Williams, Jason McCandless, and David Gregg. 2010. Dynamic Interpretation for Dynamic Scripting Languages. In Proceedings of the 8th Annual IEEE/ACM International Symposium on Code Generation and Optimization (CGO ’10). Association for Computing Machinery, New York, NY, USA. 278–287. isbn:9781605586359 https://doi.org/10.1145/1772954.1772993
Google Scholar
Digital Library
- Kevin Williams, Albert Noll, Andreas Gal, and David Gregg. 2008. Optimization Strategies for a Java Virtual Machine Interpreter on the Cell Broadband Engine. In Proceedings of the 5th Conference on Computing Frontiers (CF ’08). Association for Computing Machinery, New York, NY, USA. 189–198. isbn:9781605580777 https://doi.org/10.1145/1366230.1366265
Google Scholar
Digital Library
- Thomas Würthinger, Andreas Wöß, Lukas Stadler, Gilles Duboscq, Doug Simon, and Christian Wimmer. 2012. Self-Optimizing AST Interpreters. SIGPLAN Not., 48, 2 (2012), oct, 73–82. issn:0362-1340 https://doi.org/10.1145/2480360.2384587
Google Scholar
Digital Library
- Bennet Yee, David Sehr, Gregory Dardyk, J. Bradley Chen, Robert Muth, Tavis Ormandy, Shiki Okasaka, Neha Narula, and Nicholas Fullagar. 2010. Native Client: A Sandbox for Portable, Untrusted X86 Native Code. Commun. ACM, 53, 1 (2010), jan, 91–99. issn:0001-0782 https://doi.org/10.1145/1629175.1629203
Google Scholar
Digital Library
- Alon Zakai. 2013. asm.js: an extraordinarily optimizable, low-level subset of JavaScript. http://asmjs.org (Accessed 2021-07-29)
Google Scholar
- Mathew Zaleski, Marc Berndl, and Angela Demke Brown. 2005. Mixed Mode Execution with Context Threading. In Proceedings of the 2005 Conference of the Centre for Advanced Studies on Collaborative Research (CASCON ’05). IBM Press, 305–319.
Google Scholar
Digital Library
- Qiang Zhang, Lei Xu, Xiangyu Zhang, and Baowen Xu. 2022. Quantifying the interpretation overhead of Python. Science of Computer Programming, 215 (2022), 102759. issn:0167-6423 https://doi.org/10.1016/j.scico.2021.102759
Google Scholar
Digital Library
- Massimiliano Zilli, Wolfgang Raschke, Reinhold Weiss, Johannes Loinig, and Christian Steger. 2015. Hardware/Software Co-Design for a High-Performance Java Card Interpreter in Low-End Embedded Systems. Microprocess. Microsyst., 39, 8 (2015), nov, 1076–1086. issn:0141-9331 https://doi.org/10.1016/j.micpro.2015.05.004
Google Scholar
Digital Library
- Massimiliano Zilli, Wolfgang Raschke, Reinhold Weiss, Christian Steger, and Johannes Loinig. 2015. A Light-Weight Compression Method for Java Card Technology. SIGBED Rev., 11, 4 (2015), jan, 13–18. https://doi.org/10.1145/2724942.2724944
Google Scholar
Digital Library
Index Terms
A fast in-place interpreter for WebAssembly
Recommendations
Towards a WebAssembly standalone runtime on GraalVM
SPLASH Companion 2019: Proceedings Companion of the 2019 ACM SIGPLAN International Conference on Systems, Programming, Languages, and Applications: Software for HumanityWebAssembly is a binary format compilation target for languages such as C/C++, Rust and Go. It enables execution within Web browsers and as standalone programs. Compiled modules may interoperate with other languages such as JavaScript, and use external ...
Using WebAssembly to Teach Code Generation in a Compiler Design Course
SIGCSE 2022: Proceedings of the 53rd ACM Technical Symposium on Computer Science Education V. 2For many students, code generation is the most demanding topic covered in a typical undergraduate Compiler Design course. In this poster, the author will present how he has successfully used the fairly novel and promising WebAssembly technology in his ...
Exploring Missed Optimizations in WebAssembly Optimizers
ISSTA 2023: Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and AnalysisThe prosperous trend of deploying complex applications to web browsers has boosted the development of WebAssembly (wasm) compilation toolchains. Software written in different high-level programming languages are compiled into wasm executables, ...






Comments