pith. sign in

arxiv: 2606.21919 · v1 · pith:BN3HLWKMnew · submitted 2026-06-20 · 💻 cs.SE

Bringing Managed Language Support to WebAssembly with External Library Linking

Shuyao Jiang , Ruiying Zeng , Yangfan Zhou , Michael R. Lyu This is my paper

Pith reviewed 2026-06-26 11:59 UTC · model grok-4.3

classification 💻 cs.SE
keywords WebAssemblymanaged languagesexternal library linkingclient-server architectureruntime integrationperformancemulti-language support
0
0 comments X

The pith

WALL-E connects WebAssembly modules to managed language libraries through a client-server architecture to enable native-speed execution without runtime nesting.

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The paper proposes WALL-E to bring support for managed languages like Python and Java into WebAssembly environments. It uses external library linking with a client-server setup so that Wasm code can call into the native runtimes of those languages. This avoids the slowdown of nesting one virtual machine inside another. A sympathetic reader would care because it opens WebAssembly to ecosystems used in machine learning and data processing. The evaluation claims support for ten languages and speedups of hundreds of times compared to nesting approaches.

Core claim

WALL-E employs a unique external library linking strategy, using a client-server architecture to connect Wasm modules with managed language libraries running in their native runtimes. This approach preserves the native execution speed and language feature compatibility of managed languages by eliminating the overhead associated with double-layer virtual machines. Evaluation shows that WALL-E supports ten managed languages without framework modifications and achieves a speedup of hundreds of times over the runtime nesting solution, with low communication overhead.

What carries the argument

external library linking strategy using a client-server architecture to connect Wasm modules with native managed language runtimes

If this is right

  • Supports ten managed languages without any changes to the framework.
  • Delivers speedups of hundreds of times compared to nesting runtimes.
  • Keeps communication overhead low.
  • Makes multi-language applications practical for cloud and edge computing.
  • Maintains native speed and feature compatibility for the managed languages.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • This could enable more mixed-language applications in portable environments without custom ports.
  • The client-server split might introduce new ways to handle security boundaries between components.
  • Developers might find it easier to reuse existing managed language codebases in Wasm projects.
  • Testing on additional languages or larger applications could reveal scalability limits not covered in the evaluation.

Load-bearing premise

The client-server external linking architecture can deliver the claimed performance and compatibility without introducing hidden overheads, security issues, or language-specific incompatibilities that would require per-language changes.

What would settle it

A direct performance comparison on a concrete task in one supported language, measuring if WALL-E achieves hundreds of times faster execution than nesting while keeping overhead low.

Figures

Figures reproduced from arXiv: 2606.21919 by Michael R. Lyu, Ruiying Zeng, Shuyao Jiang, Yangfan Zhou.

Figure 1
Figure 1. Figure 1: Current language support mechanism of Wasm for different types of programming languages. [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Figure 2: The framework design of WALL-E: A client-server architecture that registers and invokes external [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Figure 3: Example registration metadata of a Python library. [PITH_FULL_IMAGE:figures/full_fig_p008_3.png] view at source ↗
Figure 4
Figure 4. Figure 4: Example invocation metadata of a Python library. [PITH_FULL_IMAGE:figures/full_fig_p009_4.png] view at source ↗
Figure 5
Figure 5. Figure 5: A representative Python failed case. The benchmark assumes a module-level [PITH_FULL_IMAGE:figures/full_fig_p013_5.png] view at source ↗
Figure 6
Figure 6. Figure 6: A representative PHP failed case. The benchmark relies on OS-level process management ( [PITH_FULL_IMAGE:figures/full_fig_p014_6.png] view at source ↗
Figure 7
Figure 7. Figure 7: The complete external library invocation process in WALL-E. [PITH_FULL_IMAGE:figures/full_fig_p017_7.png] view at source ↗
read the original abstract

WebAssembly (Wasm) has emerged as a powerful bytecode format for running applications with near-native performance in portable and secure environments. However, while Wasm currently supports compiled languages like C, C++, and Rust, it lacks robust support for managed languages such as Python, Java, and JavaScript. This limitation hinders the deployment of applications in domains like machine learning and data processing that rely heavily on managed language ecosystems. To address this, we propose WALL-E, a novel framework to integrate managed languages into Wasm environments without complex runtime nesting or recompilation. WALL-E employs a unique external library linking strategy, using a client-server architecture to connect Wasm modules with managed language libraries running in their native runtimes. This approach preserves the native execution speed and language feature compatibility of managed languages by eliminating the overhead associated with double-layer virtual machines. Our evaluation shows that WALL-E supports ten managed languages without framework modifications and achieves a speedup of hundreds of times over the runtime nesting solution, with low communication overhead. WALL-E enhances the practicality of Wasm in cloud and edge computing, enabling efficient multi-language applications.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, simulated authors' rebuttal, and a circularity audit. Tearing a paper down is the easy half of reading it; the pith above is the substance, this is the friction.

Referee Report

1 major / 0 minor

Summary. The manuscript proposes WALL-E, a client-server external library linking framework to integrate managed languages (e.g., Python, Java, JavaScript) into WebAssembly without runtime nesting or recompilation. It claims support for ten managed languages without framework modifications, hundreds-of-times speedups over nesting solutions, and low communication overhead, with applications in cloud/edge computing and ML/data processing.

Significance. If substantiated, the approach would meaningfully expand Wasm applicability to managed-language ecosystems by avoiding double-VM overhead while preserving native speeds and compatibility. No machine-checked proofs, reproducible artifacts, or parameter-free derivations are described.

major comments (1)
  1. [Abstract] Abstract: the central claims of 'supports ten managed languages without framework modifications' and 'achieves a speedup of hundreds of times over the runtime nesting solution, with low communication overhead' are asserted without any description of evaluation methodology, benchmarks used, languages tested, measurement of communication overhead, error bars, or security analysis. These details are load-bearing for the practicality claim.

Simulated Author's Rebuttal

1 responses · 0 unresolved

We thank the referee for their review of our manuscript. We address the major comment below.

read point-by-point responses

  1. Referee: [Abstract] Abstract: the central claims of 'supports ten managed languages without framework modifications' and 'achieves a speedup of hundreds of times over the runtime nesting solution, with low communication overhead' are asserted without any description of evaluation methodology, benchmarks used, languages tested, measurement of communication overhead, error bars, or security analysis. These details are load-bearing for the practicality claim.

    Authors: The abstract is a concise summary of the paper's contributions and results, as is conventional. The evaluation methodology, benchmarks (including ML and data-processing workloads), the ten managed languages tested without framework changes, communication-overhead measurements, performance results with error bars, and the comparison against nested runtimes are all described in detail in Section 5 (Evaluation). The client-server external-linking design and its security properties (leveraging Wasm isolation) are discussed in Section 4. These sections substantiate the practicality claims; the abstract simply reports the headline outcomes. revision: no

Circularity Check

0 steps flagged

No significant circularity

full rationale

The manuscript describes an engineering framework (WALL-E) using a client-server external linking architecture for managed-language support in WebAssembly. No equations, fitted parameters, self-citations as load-bearing premises, or uniqueness theorems appear in the provided text. Performance and compatibility claims rest on implementation and empirical benchmarks rather than any derivation that reduces to its own inputs by construction. The paper is self-contained against external benchmarks with no detectable circular steps.

Axiom & Free-Parameter Ledger

0 free parameters · 0 axioms · 0 invented entities

Abstract-only review supplies no explicit free parameters, axioms, or invented entities; the central claim rests on unstated assumptions about communication overhead and compatibility that are not detailed.

pith-pipeline@v0.9.1-grok · 5727 in / 986 out tokens · 17404 ms · 2026-06-26T11:59:42.692282+00:00 · methodology

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Reference graph

Works this paper leans on

85 extracted references · 48 canonical work pages · 1 internal anchor

  1. [1]

    Varun Agrawal, Abhiroop Dabral, Tapti Palit, Yongming Shen, and Michael Ferdman. 2015. Architectural support for dynamic linking. In Proceedings of the Twentieth International Conference on Architectural Support for Programming Languages and Operating Systems . 691–702. doi:10.1145/2694344.2694392

    work page doi:10.1145/2694344.2694392 2015

  2. [2]

    Asen Alexandrov. 2023. Adding Python WASI support to Wasm Language Runtimes. https://wasmlabs.dev/articles/ python-wasm32-wasi/

    2023

  3. [3]

    Bytecode Alliance. 2025. Wasmtime. https://github.com/bytecodealliance/wasmtime

    2025

  4. [4]

    Anil Altinay, Joseph Nash, Taddeus Kroes, Prabhu Rajasekaran, Dixin Zhou, Adrian Dabrowski, David Gens, Yeoul Na, Stijn Volckaert, Cristiano Giuffrida, et al. 2020. BinRec: dynamic binary lifting and recompilation. In Proceedings of the Fifteenth European Conference on Computer Systems . 1–16. doi:10.1145/3342195.3387550

    work page doi:10.1145/3342195.3387550 2020

  5. [5]

    Sean Bartell, Will Dietz, and Vikram S Adve. 2020. Guided linking: dynamic linking without the costs. Proceedings of the ACM on Programming Languages 4, OOPSLA (2020), 1–29. doi:10.1145/3428213

    work page doi:10.1145/3428213 2020

  6. [6]

    Jay Bosamiya, Wen Shih Lim, and Bryan Parno. 2022. {Provably-Safe} multilingual software sandboxing using {WebAssembly}. In 31st USENIX Security Symposium (USENIX Security 22) . 1975–1992. https://www.usenix.org/ conference/usenixsecurity22/presentation/bosamiya

    2022

  7. [7]

    Weimin Chen, Zihan Sun, Haoyu Wang, Xiapu Luo, Haipeng Cai, and Lei Wu. 2022. WASAI: uncovering vulnerabilities in Wasm smart contracts. In Proceedings of the 31st ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). 703–715. doi:10.1145/3533767.3534218

    work page doi:10.1145/3533767.3534218 2022

  8. [8]

    Lin Clark. 2019. Standardizing WASI: A system interface to run WebAssembly outside the web.Mozilla Hacks–the Web developer blog (2019). https://hacks.mozilla.org/2019/03/standardizing-wasi-a-webassembly-system-interface/

    2019

  9. [9]

    Bjorn De Sutter, Bruno De Bus, and Koen De Bosschere. 2005. Link-time binary rewriting techniques for program compaction. ACM Transactions on Programming Languages and Systems (TOPLAS) 27, 5 (2005), 882–945. doi:10.1145/ 1086642.1086645

    arXiv 2005

  10. [10]

    Wei Dong, Chun Chen, Xue Liu, Jiajun Bu, and Yunhao Liu. 2009. Dynamic linking and loading in networked embedded systems. In 2009 IEEE 6th international conference on mobile adhoc and sensor systems . IEEE, 554–562. doi:10.1109/mobhoc.2009.5336957

    work page doi:10.1109/mobhoc.2009.5336957 2009

  11. [11]

    Nicola Dragoni, Saverio Giallorenzo, Alberto Lluch Lafuente, Manuel Mazzara, Fabrizio Montesi, Ruslan Mustafin, and Larisa Safina. 2017. Microservices: yesterday, today, and tomorrow. Present and ulterior software engineering (2017), 195–216. doi:10.1007/978-3-319-67425-4_12

    work page doi:10.1007/978-3-319-67425-4_12 2017

  12. [12]

    Adam Dunkels, Niclas Finne, Joakim Eriksson, and Thiemo Voigt. 2006. Run-time dynamic linking for reprogramming wireless sensor networks. In Proceedings of the 4th international conference on Embedded networked sensor systems . 15–28. doi:10.1145/1182807.1182810

    work page doi:10.1145/1182807.1182810 2006

  13. [13]

    Unreal Engine. 2025. Unreal Engine. https://www.unrealengine.com/

    2025

  14. [14]

    FastAPI. 2025. FastAPI. https://fastapi.tiangolo.com/

    2025

  15. [15]

    Michael Franz. 1997. Dynamic linking of software components. Computer 30, 3 (1997), 74–81. doi:10.1109/2.573670

    work page doi:10.1109/2.573670 1997

  16. [16]

    Philipp Gackstatter, Pantelis A Frangoudis, and Schahram Dustdar. 2022. Pushing serverless to the edge with we- bassembly runtimes. In 2022 22nd IEEE International Symposium on Cluster, Cloud and Internet Computing (CCGrid) . IEEE, 140–149. doi:10.1109/ccgrid54584.2022.00023

    work page doi:10.1109/ccgrid54584.2022.00023 2022

  17. [17]

    Phani Kishore Gadepalli, Sean McBride, Gregor Peach, Ludmila Cherkasova, and Gabriel Parmer. 2020. Sledge: A serverless-first, light-weight wasm runtime for the edge. In Proceedings of the 21st international middleware conference . 265–279. doi:10.1145/3423211.3425680

    work page doi:10.1145/3423211.3425680 2020

  18. [18]

    Benchmarks Game. 2018. The Computer Language Benchmarks Game. https://benchmarksgame-team.pages.debian. net/benchmarksgame/

    2018

  19. [19]

    Adam T Geller, Justin Frank, and William J Bowman. 2024. Indexed Types for a Statically Safe WebAssembly.Proceedings of the ACM on Programming Languages 8, POPL (2024), 2395–2424. doi:10.1145/3632922

    work page doi:10.1145/3632922 2024

  20. [20]

    Google. 2023. A new way to bring garbage collected programming languages efficiently to WebAssembly. https: //v8.dev/blog/wasm-gc-porting

    2023

  21. [21]

    Google. 2025. V8 JavaScript Engine. https://v8.dev/

    2025

  22. [22]

    Matthias Grimmer, Roland Schatz, Chris Seaton, Thomas Würthinger, Mikel Luján, and Hanspeter Mössenböck. 2018. Cross-language interoperability in a multi-language runtime. ACM Transactions on Programming Languages and Systems (TOPLAS) 40, 2 (2018), 1–43. doi:10.1145/3201898

    work page doi:10.1145/3201898 2018

  23. [23]

    Safia Guellil and Marc Sánchez-Artigas. 2025. Optimizing WebAssembly Garbage Collection in Go: Performance Insights, Tuning Tips, and Batch Execution Strategies. In 2025 IEEE 45th International Conference on Distributed Computing Systems (ICDCS). IEEE, 670–680. doi:10.1109/icdcs63083.2025.00071

    work page doi:10.1109/icdcs63083.2025.00071 2025

  24. [24]

    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 . 27–36. doi:10.1145/3357390.3361029 Proc. ACM Softw. Eng., Vol. 3, No. FSE, Article FSE175. Publication date:...

    work page doi:10.1145/3357390.3361029 2019

  25. [25]

    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. InProceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation . 185–200. doi:10.1145/3062341.3062363

    work page doi:10.1145/3062341.3062363 2017

  26. [26]

    Ningyu He, Zhehao Zhao, Jikai Wang, Yubin Hu, Shengjian Guo, Haoyu Wang, Guangtai Liang, Ding Li, Xiangqun Chen, and Yao Guo. 2023. Eunomia: enabling user-specified fine-grained search in symbolically executing WebAssembly binaries. In Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA) . 385–397. doi:10.11...

    work page doi:10.1145/3597926.3598064 2023

  27. [27]

    Aaron Hilbig, Daniel Lehmann, and Michael Pradel. 2021. An empirical study of real-world webassembly binaries: Security, languages, use cases. In Proceedings of the Web Conference 2021 . 2696–2708. doi:10.1145/3442381.3450138

    work page doi:10.1145/3442381.3450138 2021

  28. [28]

    W Wilson Ho and Ronald A Olsson. 1991. An approach to genuine dynamic linking. Software: Practice and Experience 21, 4 (1991), 375–390. doi:10.1002/spe.4380210404

    work page doi:10.1002/spe.4380210404 1991

  29. [29]

    Shashank Mohan Jain and Shashank Mohan Jain. 2022. Extending Istio with WebAssembly. WebAssembly for Cloud: A Basic Guide for Wasm-Based Cloud Apps (2022), 151–160. doi:10.1007/978-1-4842-7496-5_8

    work page doi:10.1007/978-1-4842-7496-5_8 2022

  30. [30]

    Abhinav Jangda, Bobby Powers, Emery D Berger, and Arjun Guha. 2019. Not so fast: Analyzing the performance of {WebAssembly} vs. native code. In 2019 USENIX Annual Technical Conference (USENIX ATC 19) . 107–120. https: //www.usenix.org/conference/atc19/presentation/jangda

    2019

  31. [31]

    Shuyao Jiang, Ruiying Zeng, Zihao Rao, Jiazhen Gu, Yangfan Zhou, and Michael R. Lyu. 2023. Revealing Performance Issues in Server-side WebAssembly Runtimes via Differential Testing. InProceedings of the 38th IEEE/ACM International Conference on Automated Software Engineering (ASE) . IEEE, 661–672. doi:10.1109/ase56229.2023.00088

    work page doi:10.1109/ase56229.2023.00088 2023

  32. [32]

    Shuyao Jiang, Ruiying Zeng, Yangfan Zhou, and Michael R. Lyu. 2025. Distinguishability-guided Test Program Generation for WebAssembly Runtime Performance Testing. InProceedings of the 32nd IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER) . IEEE, 768–779. doi:10.1109/saner64311.2025.00078

    work page doi:10.1109/saner64311.2025.00078 2025

  33. [33]

    Evan Johnson, Evan Laufer, Zijie Zhao, Dan Gohman, Shravan Narayan, Stefan Savage, Deian Stefan, and Fraser Brown

  34. [34]

    3209–3227 (2023)

    WaVe: a verifiably secure WebAssembly sandboxing runtime. In2023 IEEE Symposium on Security and Privacy (SP). IEEE, 2940–2955. doi:10.1109/sp46215.2023.10179357

    work page doi:10.1109/sp46215.2023.10179357 2023

  35. [35]

    VMware Labs. 2025. WebAssembly Language Runtimes. https://github.com/vmware-labs/webassembly-language- runtimes

    2025

  36. [36]

    Daniel Lehmann, Johannes Kinder, and Michael Pradel. 2020. Everything old is new again: Binary security of {WebAssembly}. In 29th USENIX Security Symposium (USENIX Security 20) . 217–234. https://www.usenix.org/ conference/usenixsecurity20/presentation/lehmann

    2020

  37. [37]

    Daniel Lehmann and Michael Pradel. 2019. Wasabi: A framework for dynamically analyzing webassembly. InProceedings of the Twenty-Fourth International Conference on Architectural Support for Programming Languages and Operating Systems. 1045–1058. doi:10.1145/3297858.3304068

    work page doi:10.1145/3297858.3304068 2019

  38. [38]

    Daniel Lehmann, Michelle Thalakottur, Frank Tip, and Michael Pradel. 2023. That’s a Tough Call: Studying the Challenges of Call Graph Construction for WebAssembly. In Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA). 892–903. doi:10.1145/3597926.3598104

    work page doi:10.1145/3597926.3598104 2023

  39. [39]

    Li Li, Wu Chou, Wei Zhou, and Min Luo. 2016. Design patterns and extensibility of REST API for networking applications. IEEE Transactions on Network and Service Management 13, 1 (2016), 154–167. doi:10.1109/tnsm.2016.2516946

    work page doi:10.1109/tnsm.2016.2516946 2016

  40. [40]

    Zhibo Liu, Dongwei Xiao, Zongjie Li, Shuai Wang, and Wei Meng. 2023. Exploring missed optimizations in webassembly optimizers. In Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis (ISSTA) . 436–448. doi:10.1145/3597926.3598068

    work page doi:10.1145/3597926.3598068 2023

  41. [41]

    Niko Mäkitalo, Victor Bankowski, Paulius Daubaris, Risto Mikkola, Oleg Beletski, and Tommi Mikkonen. 2021. Bringing webassembly up to speed with dynamic linking. InProceedings of the 36th Annual ACM Symposium on Applied Computing. 1727–1735. doi:10.1145/3412841.3442045

    work page doi:10.1145/3412841.3442045 2021

  42. [42]

    Niko Mäkitalo, Tommi Mikkonen, Cesare Pautasso, Victor Bankowski, Paulius Daubaris, Risto Mikkola, and Oleg Beletski. 2021. WebAssembly modules as lightweight containers for liquid IoT applications. In International Conference on Web Engineering. Springer, 328–336. doi:10.1007/978-3-030-74296-6_25

    work page doi:10.1007/978-3-030-74296-6_25 2021

  43. [43]

    Scott Malabarba, Raju Pandey, Jeff Gragg, Earl Barr, and J Fritz Barnes. 2000. Runtime support for type-safe dynamic Java classes. In European Conference on Object-Oriented Programming . Springer, 337–361. doi:10.1007/3-540-45102-1_17

    work page doi:10.1007/3-540-45102-1_17 2000

  44. [44]

    Pankaj Mendki. 2020. Evaluating webassembly enabled serverless approach for edge computing. In 2020 IEEE Cloud Summit. IEEE, 161–166. doi:10.1109/ieeecloudsummit48914.2020.00031

    work page doi:10.1109/ieeecloudsummit48914.2020.00031 2020

  45. [45]

    Jämes Ménétrey, Marcelo Pasin, Pascal Felber, and Valerio Schiavoni. 2021. Twine: An embedded trusted runtime for webassembly. In 2021 IEEE 37th International Conference on Data Engineering (ICDE) . IEEE, 205–216. doi:10.1109/ icde51399.2021.00025

    arXiv 2021

  46. [46]

    Konrad Moron and Stefan Wallentowitz. 2023. Support for Just-in-Time Compilation of WebAssembly for Embedded Systems. In 2023 12th Mediterranean Conference on Embedded Computing (MECO) . IEEE, 1–4. doi:10.1109/meco58584. 2023.10155088 Proc. ACM Softw. Eng., Vol. 3, No. FSE, Article FSE175. Publication date: July 2026. Bringing Managed Language Support to ...

    work page doi:10.1109/meco58584 2023

  47. [47]

    Mozilla. 2025. SpiderMonkey. https://spidermonkey.dev/

    2025

  48. [48]

    Otoya Nakakaze, István Koren, Florian Brillowski, and Ralf Klamma. 2022. Retrofitting industrial machines with webassembly on the edge. In International Conference on Web Information Systems Engineering . Springer, 241–256. doi:10.1007/978-3-031-20891-1_18

    work page doi:10.1007/978-3-031-20891-1_18 2022

  49. [49]

    Shravan Narayan, Craig Disselkoen, Daniel Moghimi, Sunjay Cauligi, Evan Johnson, Zhao Gang, Anjo Vahldiek- Oberwagner, Ravi Sahita, Hovav Shacham, Dean Tullsen, et al . 2021. Swivel: Hardening {WebAssembly} against spectre. In 30th USENIX Security Symposium (USENIX Security 21) . 1433–1450. https://www.usenix.org/conference/ usenixsecurity21/presentation/narayan

    2021

  50. [50]

    O’Reilly Media, Inc

    Sam Newman. 2021. Building microservices: designing fine-grained systems . " O’Reilly Media, Inc. ". https://www.oreilly. com/library/view/building-microservices-2nd/9781492034018/

    arXiv 2021

  51. [51]

    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) . IEEE, 168–178. doi:10.1109/ic2e52221.2021.00032

    work page doi:10.1109/ic2e52221.2021.00032 2021

  52. [52]

    OpenJS. 2025. Express. https://expressjs.com/

    2025

  53. [53]

    Pallets. 2025. Flask. https://flask.palletsprojects.com/en/stable/

    2025

  54. [54]

    Michael P Papazoglou, Paolo Traverso, Schahram Dustdar, and Frank Leymann. 2007. Service-oriented computing: State of the art and research challenges. Computer 40, 11 (2007), 38–45. doi:10.1109/mc.2007.400

    work page doi:10.1109/mc.2007.400 2007

  55. [55]

    Python. 2025. CPython. https://github.com/python/cpython

    2025

  56. [56]

    Python. 2025. jsonschema. https://python-jsonschema.readthedocs.io/en/stable/

    2025

  57. [57]

    Python. 2025. Python-Markdown. https://pypi.org/project/Markdown/

    2025

  58. [58]

    Python. 2025. The Python Performance Benchmark Suite. https://pyperformance.readthedocs.io/index.html

    2025

  59. [59]

    RedMonk. 2022. The RedMonk Programming Language Rankings. https://redmonk.com/sogrady/2022/03/28/language- rankings-1-22/

    2022

  60. [60]

    Micha Reiser and Luc Bläser. 2017. Accelerate JavaScript applications by cross-compiling to WebAssembly. In Proceedings of the 9th ACM SIGPLAN International Workshop on Virtual Machines and Intermediate Languages . 10–17. doi:10.1145/3141871.3141873

    work page doi:10.1145/3141871.3141873 2017

  61. [61]

    Yuxin Ren, Kang Zhou, Jianhai Luan, Yunfeng Ye, Shiyuan Hu, Xu Wu, Wenqin Zheng, Wenfeng Zhang, and Xinwei Hu. 2022. From dynamic loading to extensible transformation: An infrastructure for dynamic library transformation. In 16th USENIX Symposium on Operating Systems Design and Implementation (OSDI 22) . 649–666. https://www.usenix. org/conference/osdi22/...

    2022

  62. [62]

    Alan Romano, Daniel Lehmann, Michael Pradel, and Weihang Wang. 2022. Wobfuscator: Obfuscating javascript malware via opportunistic translation to webassembly. In 2022 IEEE Symposium on Security and Privacy (SP) . IEEE, 1574–1589. doi:10.1109/sp46214.2022.9833626

    work page doi:10.1109/sp46214.2022.9833626 2022

  63. [63]

    Alan Romano and Weihang Wang. 2023. When Function Inlining Meets WebAssembly: Counterintuitive Impacts on Runtime Performance. In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE) . ACM, 350–362. doi:10.1145/3611643.3616311

    work page doi:10.1145/3611643.3616311 2023

  64. [64]

    Merlijn Sebrechts, Tim Ramlot, Sander Borny, Tom Goethals, Bruno Volckaert, and Filip De Turck. 2022. Adapting Kubernetes controllers to the edge: on-demand control planes using Wasm and WASI. In 2022 IEEE 11th International Conference on Cloud Networking (CloudNet) . IEEE, 195–202. doi:10.1109/cloudnet55617.2022.9978884

    work page doi:10.1109/cloudnet55617.2022.9978884 2022

  65. [65]

    Hovav Shacham, Matthew Page, Ben Pfaff, Eu-Jin Goh, Nagendra Modadugu, and Dan Boneh. 2004. On the effectiveness of address-space randomization. In Proceedings of the 11th ACM Conference on Computer and Communications Security . 298–307. doi:10.1145/1030083.1030124

    work page doi:10.1145/1030083.1030124 2004

  66. [66]

    Simon Shillaker and Peter Pietzuch. 2020. Faasm: Lightweight isolation for efficient stateful serverless computing. In 2020 USENIX Annual Technical Conference (USENIX ATC 20) . 419–433. https://www.usenix.org/conference/atc20/ presentation/shillaker

    2020

  67. [67]

    Shopify. 2023. Bringing JavaScript to WebAssembly for Shopify Functions. https://shopify.engineering/javascript-in- webassembly-for-shopify-functions

    2023

  68. [68]

    Mark Slee, Aditya Agarwal, and Marc Kwiatkowski. 2007. Thrift: Scalable cross-language services implementation. Facebook white paper 5, 8 (2007), 127. https://thrift.apache.org/static/files/thrift-20070401.pdf

    2007

  69. [69]

    Spring. 2025. Spring Boot. https://spring.io/projects/spring-boot

    2025

  70. [70]

    Second State. 2025. WasmEdge-QuickJS. https://github.com/second-state/wasmedge-quickjs

    2025

  71. [71]

    Thomas Steiner. 2024. Toward Making Opaque Web Content More Accessible: Accessibility From Adobe Flash to Canvas- Rendered Apps. In Companion Proceedings of the ACM Web Conference 2024 . 1111–1114. doi:10.1145/3589335.3651999

    work page doi:10.1145/3589335.3651999 2024

  72. [72]

    Quentin Stiévenart, David W Binkley, and Coen De Roover. 2022. Static stack-preserving intra-procedural slicing of webassembly binaries. In Proceedings of the 44th International Conference on Software Engineering (ICSE) . 2031–2042. doi:10.1145/3510003.3510070 Proc. ACM Softw. Eng., Vol. 3, No. FSE, Article FSE175. Publication date: July 2026. FSE175:24 S...

    work page doi:10.1145/3510003.3510070 2022

  73. [73]

    Ben L Titzer. 2022. A fast in-place interpreter for WebAssembly. Proceedings of the ACM on Programming Languages 6, OOPSLA2 (2022), 646–672. doi:10.1145/3563311

    work page doi:10.1145/3563311 2022

  74. [74]

    Unity. 2025. Unity. https://unity.com/

    2025

  75. [75]

    Luke Wagner. 2017. A WebAssembly milestone: Experimental support in multiple browsers. Mozilla Hacks (14 March 2016). (2017). https://hacks.mozilla.org/2016/03/a-webassembly-milestone/

    2017

  76. [76]

    Dong Wang, Bo Jiang, and WK Chan. 2020. WANA: Symbolic execution of wasm bytecode for cross-platform smart contract vulnerability detection. arXiv preprint arXiv:2007.15510 (2020). doi:10.48550/arXiv.2007.15510

    work page doi:10.48550/arxiv.2007.15510 2020

  77. [77]

    WasmEdge. 2025. WasmEdge. https://github.com/WasmEdge/WasmEdge

    2025

  78. [78]

    WasmEdge. 2025. WasmEdge HTTP Services. https://wasmedge.org/docs/category/http-services

    2025

  79. [79]

    Wasmer. 2025. Wasmer. https://github.com/wasmerio/wasmer

    2025

  80. [80]

    Elliott Wen and Jens Dietrich. 2023. Wasmslim: Optimizing webassembly binary distribution via automatic module splitting. In 2023 IEEE International Conference on Software Analysis, Evolution and Reengineering (SANER) . IEEE, 673–677. doi:10.1109/saner56733.2023.00069

    work page doi:10.1109/saner56733.2023.00069 2023

Showing first 80 references.