WebAssembly/Wasm and OCaml
In this first post about WebAssembly (Wasm) and OCaml, we introduce the work we have been doing for quite some time now, though without publicity, about our participation in the Garbage-Collection (GC) Working Group for Wasm, and two related development projects in OCaml.
WebAssembly, a fast and portable bytecode
WebAssembly is a low-level, binary format that allows compiled code to run efficiently in the browser. Its roadmap is decided by Working Groups from multiple organizations and companies, including Microsoft, Google, and Mozilla. These groups meet regularly to discuss and plan the development of WebAssembly, with the broader community of developers, academics, and other interested parties to gather feedback and ideas for the future of WebAssembly.
There are multiple projects in OCaml related to Wasm, notably
Wasicaml, a production-ready port of the OCaml bytecode interpreter
to Wasm . However, these projects don't tackle the domain we would
like to address, and for good reasons: they target the existing
version of Wasm, which is basically a very simple programming language
with no data structures, but with an access to a large memory
array. Almost anything can of course be compiled to something like
that, but there is a big restriction: the resulting program can
interact with the outside world only through the aforementioned memory buffer.
This is perfectly fine if you write Command-Line Interface (CLI) tools,
or workers to be deployed in a Content Delivery Network (CDN). However,
this kind of interaction can become quite tedious if you need to deal
with abstract objects provided by your environment, for example DOM
objects in a browser to manipulate webpages. In such cases, you will
js_of_ocaml of course), and you will have to be very careful
about the lifetime of those objects to avoid memory leaks.
Hence the shiny new proposals to extend Wasm with various useful features that can be very convenient for OCaml. In particular, three extensions crucially matter to us, functional programmers: the Garbage Collection, Exceptions and Tail-Call proposals.
Our involvement in the GC-related Working Group
The Wasm committee has already worked on these proposals for a few years, and the Exceptions and Tail-Call proposals are now quite satisfying. However, this is not yet the case for the GC proposal. Indeed, finding a good API for a GC that is compatible with all the languages in the wild, that can be implemented efficiently, and can be used to run a program you don't trust, is all but an easy task. Multiple attempts by strong teams, for different virtual machines, have exposed limitations of past proposals. But, we must now admit that the current proposal has reached a state where it is quite impressive, being both simple and generic.
The proposal is now getting close to a feature freeze status. Thanks to the hard work of many people on the committee, including us, the particularities of functional typed languages were not forgotten in the design, and we are convinced that there should be no problem for OCaml. Now is the time to test it for real!
Targetting Wasm from the OCaml Compiler
Adding a brand new backend to a compiler to target something that is quite different from your usual assembly can be a huge work, and only a few language developers actively work on making a prototype for Wasm+GC. Yet, we think that it is important for the committee, to have as many examples as possible to validate the proposal and move it to the next step.
That's the reason why we decided to contribute to the proposal, by prototyping a backend for Wasm to the OCaml compiler.
Our experimental Wasm interpreter in OCaml
In parallel, we are also working on the development of our own Wasm Virtual Machine in OCaml, to be able to easily experiment both on the OCaml side and Wasm side, while waiting for most official Wasm VM to fully implement the new proposals.
These experimental projects and related discussions are very important design steps, although obviously far from production-ready status.
As our current work focuses on OCaml 4.14, effect handlers are left for future work. The current proposal that would make it possible to compile effect handlers to Wasm nicely is still in its earlier stages. We hope to be able to prototype it too on our Wasm VM.
Note that we are looking for sponsors to fund this work. If supporting Wasm in OCaml may impact your business, you can contact us to discuss how we can use your help!
Our next blog post in January will provide more technical details on our two prototyping efforts.
OCamlPro is a R&D lab founded in 2011, with the mission to help industrial users benefit from experts with a state-of-the-art knowledge of programming languages theory and practice.
- We provide audit, support, custom developer tools and training for both the most modern languages, such as Rust, WASM and OCaml, and for legacy languages, such as COBOL or even home-made domain-specific languages;
- We design, create and implement software with great added-value for our clients. High complexity is not a problem for our PhD-level experts. For example, we developed the prototype of the Tezos proof-of-stake blockchain.
- We have a long history of creating open-source projects, such as the Opam package manager, the LearnOCaml web platform, and contributing to other ones, such as the Flambda optimizing compiler, or the GnuCOBOL compiler.
- We are also experts of Formal Methods, developing tools such as our SMT Solver Alt-Ergo (check our Alt-Ergo Users' Club) and using them to prove safety or security properties of programs.