GraalJS 25.1: Modern JavaScript on GraalVM

GraalJS, the high-performance embeddable JavaScript implementation on GraalVM, is here with the latest ECMAScript features!

JavaScript is a core part of modern web development. At Oracle, we use it in multiple ways: to build products and services, to let developers extend our platforms, and to connect applications with Oracle services.

We also participate in moving the language forward. Oracle is part of Ecma International and TC39, the committee that evolves ECMAScript, the standardized language implemented by JavaScript engines.

GraalJS is a key part of that work. It is modern, fast, easy to embed in Java and Kotlin applications, and interoperable with GraalPy and other Graal Languages. Through GraalJS’s support for Node, it can also run Node.js applications, and it uses GraalWasm to implement the WebAssembly JavaScript API.

GraalJS is developed in the open, with source code and community distributions available under the Universal Permissive License (UPL). GraalJS is published on GitHub and Maven Central, and its compatibility work is tested against Test262, the official ECMAScript conformance suite with more than 50,000 tests.

The unique features of GraalJS, such as embeddability and fast interoperability with Java, enable several important use cases in Oracle’s systems. NetSuite is a good example: SuiteScript, its scripting engine that supports sophisticated procedural logic, is powered by GraalJS. For customers and partners developing in SuiteScript, this provides access to the full range of modern JavaScript language features out of the box.

Oracle Database takes the idea of embeddability in another direction. The Multilingual Engine (MLE) in Oracle Database lets developers run JavaScript close to the data, including dynamic snippets and JavaScript modules stored in the database. Under the hood, MLE uses GraalVM’s embedding and Native Image capabilities to bring JavaScript execution into the database environment.

The latest release, GraalJS 25.1, ships full support for ECMAScript 2026, the 17th edition of the ECMAScript standard, and makes it the default language version.

For most applications, no extra configuration is required: the latest standardized JavaScript language and library features are available out of the box. Applications that need to pin a specific ECMAScript version for compatibility can continue to do so with the js.ecmascript-version option.

ECMAScript 2026 Highlights

ECMAScript 2026 standardizes practical additions across numeric computation, iterators, asynchronous data collection, error detection, keyed collections, binary encoding, and JSON processing. These features are available by default in GraalJS 25.1.

• Array.fromAsync() constructs arrays from async iterables, sync iterables, and array-like inputs. It also accepts an optional mapping function applied to each element, and the result is awaited before it is added to the array.
• Iterator.concat() sequences multiple iterator or iterable inputs into one lazy iterator, so iterator-based code can stay composable without allocating intermediate arrays.
• Math.sumPrecise() sums an iterable of floating-point numbers with improved numerical stability and minimal precision loss, especially when values have different magnitudes. For example, Math.sumPrecise([1e16, 0.1, -1e16]) returns 0.1, while naive summation returns 0.
• Get-or-insert APIs for Map and WeakMap return an existing value when one is already present, or provide a default value during retrieval when the key is not already present: getOrInsert() and getOrInsertComputed() on Map.prototype and WeakMap.prototype. These APIs simplify common cache, memoization, and grouping patterns.
• Hex and Base64 string support for Uint8Array adds binary conversion APIs for strings of hexadecimal- and Base64-encoded binary data, including fromBase64(), toBase64(), setFromBase64(), fromHex(), toHex(), and setFromHex().
• More expressive JSON APIs let JSON.parse() revivers access the matched segment of JSON source text for the current value, which is useful to preserve precise numeric values. ES2026 also adds JSON.rawJSON() and JSON.isRawJSON(); JSON.rawJSON() allows validated raw JSON fragments to be embedded during stringification, giving applications fine-grained control over JSON.stringify() output for primitive values. Together, these additions allow serialization of BigInt values and make JSON handling more extensible.
• Error.isError() provides a standard way to test whether a value is an actual error object, instead of relying on less robust cross-realm-sensitive checks such as instanceof Error.

Beyond ECMAScript 2026

GraalJS 25.1 also includes support for selected language features outside ECMAScript 2026. Temporal is available in ECMAScript 2027 mode. Some earlier-stage proposals are available in ECMAScript staging mode, while others use explicit experimental options.

Temporal in ECMAScript 2027 Mode

GraalJS 25.1 completes support for Temporal, with modern date/time APIs such as Temporal.PlainDate for calendar dates and Temporal.ZonedDateTime for time-zone-aware scheduling and arithmetic.

Temporal is not part of ECMAScript 2026, so it is not enabled by default. Use ECMAScript 2027 mode to enable it:

js --js.ecmascript-version=2027 app.mjs

Non-Final ECMAScript Features

GraalJS 25.1 includes support for several proposals that have not been finalized yet. These features are experimental and may still change.

In ECMAScript staging mode, GraalJS 25.1 includes:

• Immutable ArrayBuffers: APIs for creating ArrayBuffers that cannot be mutated, resized, detached, or transferred: transferToImmutable() and sliceToImmutable().
• Joint Iteration: Iterator.zip() and Iterator.zipKeyed() for advancing multiple iterators together and working with positionally aligned values.

To enable ECMAScript staging features, set js.ecmascript-version to “staging”: js --js.ecmascript-version=staging app.mjs.

GraalJS 25.1 also includes additional proposals behind explicit experimental options:

• Explicit Resource Management ( --js.explicit-resource-management): using / await using declarations and disposable resource stacks for deterministic cleanup.
• Import Text (--js.import-text): imports text resources as strings, such as YAML or template files.
• Import Bytes (--js.import-bytes): imports arbitrary files as raw bytes using import attributes, returning a Uint8Array backed by an immutable ArrayBuffer.

Node.js 24

GraalJS 25.1 updates the Node support to Node.js 24.14.1, bringing the Node.js 24.x LTS line into the release alongside ECMAScript 2026 support.

Experimental Web Crypto API Option

GraalJS 25.1 also adds the experimental--js.crypto option to expose getRandomValues() and randomUUID() from the Web Crypto API. Use it with --experimental-options --js.crypto=true app.mjs.

For the full list of GraalJS changes, see the CHANGELOG on GitHub.

Conclusion

GraalJS 25.1 brings the latest JavaScript features to GraalJS by default, while keeping compatibility options available for applications that need them. It also updates to Node.js 24 and includes experimental features for developers who want to try what is coming next.

We would like to thank our contributors and community for the feedback, suggestions, and contributions that went into this release. If you have feedback on GraalJS 25.1 or suggestions for future releases, share them with us on Slack, GitHub, or Twitter.

Now go ahead and try GraalJS 25.1!