WebAssembly with Rhino

[StSchnell]

This post describes the use of WebAssembly with Rhino. WebAssembly, or Wasm for short, is a low-level binary instruction format which is primarily used on the web for client and server applications. This is intended to reduce sizes, minimize loading times and increase execution speed. dylibso, a group of software builders, offers Chicory, a runtime to use Wasm with the Java. This approach allows to run Wasm programs with zero native dependencies anywhere where the JVM can go.

From C to Wasm

To show an example how Wasm can be used with Rhino, first a simple C code that is compiled to Wasm with emscripten, a complete compiler toolchain. It contains only one function, with the name hello, with two parameters. If a name is passed the typical Hello World ... message is returned with a name, otherwise without.

#include <emscripten.h>
#include <stdlib.h>
#include <string.h>

EMSCRIPTEN_KEEPALIVE
void hello(char* name, char* result) {
  if (name == NULL) {
    char* ret = "Hello World from WebAssembly in C Language\n";
    strcpy(result, ret);
  } else {
    char* ret = "Hello ";
    strcat(ret, name);
    strcat(ret, " from WebAssembly in C Language\n");
    strcpy(result, ret);
  }
}

The following command can be used to compile this code to Wasm:

@emcc hello.c -o hello.c.wasm --no-entry -s EXPORTED_FUNCTIONS=_malloc,_free

Strings are passed and returned in this example. In this case it is necessary to use the functions malloc, to allocate memory, and free, to release the memory again.

Use Wasm with Rhino

The use in Rhino is very easy to understand. In the first steps Wasm is loaded and the functions are instantiated. The arguments for the function are prepared in the following steps. Firstly the name and secondly for the return value. The function is then invoked and the return value is output. Finally, the occupied memory is released again. Further detailed explanations can be found at the Chicory project.

function main() {

  var file = new java.io.File("./hello.c.wasm");
  var module = com.dylibso.chicory.runtime.Module.builder(file).build();
  var instance = module.instantiate();

  var hello = instance.export("hello");
  var malloc = instance.export("malloc");
  var free = instance.export("free");
  var memory = instance.memory();

  var name = "Stefan";
  var ptrName = malloc.apply(
    com.dylibso.chicory.wasm.types.Value.i32(name.length)
  )[0].asInt();
  memory.writeString(ptrName, name);

  var ptrResult = malloc.apply(
    com.dylibso.chicory.wasm.types.Value.i32(128)
  )[0].asInt();

  hello.apply(
    com.dylibso.chicory.wasm.types.Value.i32(ptrName),
    com.dylibso.chicory.wasm.types.Value.i32(ptrResult)
  );

  var result = memory.readString(ptrResult, 128);
  java.lang.System.out.println(result.trim());

  free.apply(com.dylibso.chicory.wasm.types.Value.i32(ptrResult));
  free.apply(com.dylibso.chicory.wasm.types.Value.i32(ptrName));

}

// Main
java.lang.System.out.println(
  org.mozilla.javascript.Context().getCurrentContext().getImplementationVersion()
);

main();

The Chicory JAR files can be downloaded from the MVN repository, they must be added to the classpath.

Conclusion

WebAssembly can be used with Chicory very easily with the Rhino engine. The question certainly arises whether necessity exists at all, because Rhino can easily use Java. But the situation may be differs if Wasm modules are already available or code reuse is planned, e.g. for browser and server. The use of WebAssembly with the Rhino engine opens up interesting perspectives and possibilities.

[p-bakker]

Tnx for sharing!

Would be cool to have a project/repo that would implement the JavaScript WebAssembly interface, that an embedder you easily include in their project that uses Rhino, similar to how an embedder can expose the console by calling NativeConsole.init(...)

Such project could be hosted under https://github.com/rhino as it's own repo and in the future potentially be part of a WinterGC compatible opt-in

[bhelx]

Hello @StSchnell, thanks for sharing! I'm one of the creators of Chicory. I recently did some similar with an emscripten build of sqlite. I was also able to get an emscripten build of an SNES emulator working. I see you went with writing the bindings yourself, which is probably the only viable path right now, but I've been thinking about the possibility of supporting Emscripten derived bindings explicitly. Having looked at the JavaScript bindings that emscripten generates, i think it should be possible to do something similar in Java. Let me know if you have any thoughts on this.

For this project maybe emscripten bindings would just work given it can execute the generated JS bindings.

[bhelx]

Would be cool to have a project/repo that would implement the JavaScript WebAssembly interface, that an embedder you easily include in their project that uses Rhino, similar to how an embedder can expose the console by calling NativeConsole.init(...)
Such project could be hosted under https://github.com/rhino as it's own repo and in the future potentially be part of a WinterGC compatible opt-in

@p-bakker @StSchnell would be happy to contribute to this. It's exactly the kind of thing we had in mind when we started Chicory.

[p-bakker]

Great, how would you propose to go about it? I can setup a repo and give you the relevant privileges.

[andreaTP]

Implementing JavaScript WebAssembly interface with Chicory seems straightforward, I'm happy to collaborate!
@bhelx is in parental leave those days, but I'd be happy to see steps forwards.
@p-bakker let me know how I can help 🙏

[p-bakker]

I've created an empty repo, so there's a place to send PRs to: https://github.com/rhino/rhino-wasm

As for implementation directions:

• see the implementation of console for how to provide as optional implementation. console is only enabled by default in the shell and provides API for embeddets to include it in their integration, with the ability to customize details about the integration
• see the CommonJS implementation for an example how to allow integrations to control from where source code can be loaded (I assume this might be relevant for a wasm add-on, but I might be wrong 🙂
• note that we're slowly but surely migrating away from extending IdScriptable for implementing host objects, but you'll see a lot of existing host object implementations still using it
• note: as this extension will have dependencies on an external library, it'll have to be a independent add-on. This would be the first of its kind, so we might have to figure some things out asking the way 🙂

Please let me know if this is enough to get going.

[andreaTP]

Hey @p-bakker , thanks a lot for the great start, I have started trying to figure out things, but I'm not familiar with the Rhino codebase/ecosystem and have a number of(maybe trivial) questions.

1. It's my understanding that we should provide an API implementing this spec correct?
2. the project setup should be done with Gradle? Do you have any "starter" project/example?
3. how do we plug the "ScriptableObject" class dynamically?

Thanks for the link to the "not IdScriptable" example!

[andreaTP]

Alternatively to a written reply, the project filled with an "Hello world" would be excellent :-)

[p-bakker]

I think that is the correct spec, but for a more reasonable intro this might be helpful: https://developer.mozilla.org/en-US/docs/WebAssembly/JavaScript_interface

As for plugging in the class dynamically: embedders can include the jar with the WebAssembly API implementation on their classpath and then in their integration code (Java) they would call the .init(...) method of the imported WebAssembly class. See NativeConsole.init for prior art

As this is the first of its kind, we don't have similar projects to look at I'm afraid. Rhino itself uses Gradle, so I think I'm the end it would be handy to use that as well, but for now maybe just focus on the actual implementation?

[andreaTP]

Thanks for the context, if no one else beats me on time I'll try to come up with an initial proposal

[andreaTP]

cross-posting, I started something here: rhino/rhino-wasm#1 looking for help in moving things forward 🙏

[StSchnell]

Hello @p-bakker,
I tried this code ...

  var wasm = Packages.com.dylibso.chicory.wasm;
  var file = new java.io.File("./main.wasm");
  var module = wasm.Parser.parse(file);

... to parse a wasm, but Rhino can not find the static method parse. The parse method is part of the Parser class of com.dylibso.chicory.wasm package.

public static Module parse(File file) {
 return parse(file.toPath());
}

The error message is:

Java class "com.dylibso.chicory.wasm.Parser" has no public instance field or method named "parse"

The message is true, it is not an instance method, it is a static method.
Do you have any idea why the static method is not found?
Thanks and best regards
Stefan