OpenJDK has revived the Detroit scripting engine, which provides JavaScript through V8 and Python through the native CPython engine. Since Graal already offers GraalJS and GraalPy, what problem is Detroit intended to solve? Is it mainly about performance, compatibility, licensing, or easier integration with standard OpenJDK? Does this mean GraalJS or GraalPy might eventually be discontinued?
4 Answers
Rhino is another lightweight JavaScript option, but it generally gives up a lot of performance compared with modern optimizing engines. Detroit and Graal are targeting more demanding workloads, so the choice is likely to depend on whether you value minimal dependencies, peak performance, native compatibility, or deeper Java integration.
One possible reason for using native CPython is compatibility. GraalPy has historically had trouble with some Python packages that depend heavily on CPython’s C API and native extensions. Embedding CPython gives those libraries the behavior they already expect, although GraalPy has improved considerably and now supports many popular extensions, with compatibility patches and prebuilt wheels in some cases.
The main distinction is integration and deployment. Graal can run optimized JavaScript in the same heap, with features such as Java interoperability and code caching, while its isolate-based runtime can also work through a native boundary on regular OpenJDK installations. Detroit appears aimed at making native-language engines easier to use from OpenJDK without depending on the Graal JIT compiler or JVMCI.
GraalJS and GraalPy are not being discontinued. Graal’s development is still active, and both languages can run with optimization enabled on standard JDKs through polyglot isolates. This provides a native optimized runtime without requiring a GraalVM JDK or JVMCI in every setup.
That compatibility gap has narrowed quite a bit. GraalPy still does not support every C extension perfectly, and its C API support remains experimental, but it is worth reevaluating for many packages.