es4x, a server framework on top of GraalJS and Vert.x

That was my first thought as well. I liked using E4X back in the day.

Sadly no. JS is not a thread safe language by design. However, JS can be used in multiple isolated threads simultaneously, and when they call into Java (or Kotlin or Scala etc) that codepath is shared, so you can use Java objects to share data between JavaScript contexts.

From the site:

For this reason ES4X has a few packages published on npm that make the development easier by providing a small shim to map the Java API to JavaScript plus the full API as TypeScript .d.ts definition files.

I think NPM compatibility would not be a 100% since this runs on JVM and not node.js.

No, it shouldn't, from my quick glance.

Here's a quick summary to help make things clear as mud. Graal is basically a compiler (very very incomplete summary but fine). Oracle is contributing it to OpenJDK as the JDK compiler. Truffle is a normal Java library and API for implementing programming languages in Java (again very high level incomplete summary) and it uses Graal to generate code. So you write your language in Java using Truffle as an API to do that, but get native code generated for it. They were developed together. And actually, you can actually use Truffle as a library without Graal in the mix, since it's "only" a Java library; it runs on a compatible JVM -- this is very useful for example, because the JDK running behind IntelliJ for code completion may not have Graal, but is just a normal JVM otherwise, and you really want code completion, test bench runners, etc, that require running your code under a normal JVM. But if Graal is there, it gets interesting, because fast code gets generated. This is again an incredibly incomplete summary but sufficient.

It's important to understand that Truffle is the library for programming language authors, and the "source" of the polyglot capabilities -- while Graal is the code generator.

The languages that the Graal team have implemented, such as JavaScript, are just clients of the Truffle library. Most Graal languages are just clients of Truffle and don't depend on the underlying JDK build or anything. If two languages are clients of the Truffle library, loaded into the same JVM, and properly implement the Polyglot API protocols, then they can also communicate, too.

You can just have a dependency on the Truffle JavaScript implementation, like any normal Java dependency, and it will run on the Enterprise or normal open source JVM.

The only reason you would force a dependency on the Enterprise Edition of Graal is if you relied in some specific Enterprise feature of theirs at the code level, but I don't know of any off hand; they're probably there, though. I believe you can detect this at runtime anyway and just do feature detection, too.

There are more technical details, but that's the summary. It's unclear how this will all shake out once Graal is part of OpenJDK and developed there; I suspect the Polyglot languages developed by the teams at Oracle will be moved around, but the above description should (basically) still be accurate.

It seems that openjdk is fine: https://reactiverse.io/es4x/get-started/install.html#graalvm...

Both are Oracle's, what was contributed is the community edition.

And they still do like 90% of the OpenJDK work anyway.