The departure of Nashorn from the JDK left a void for Java developers needing to execute JavaScript within their applications. GraalJS, part of the revolutionary GraalVM project, doesn't just fill this void—it completely redefines what's possible by providing a high-performance, ECMAScript-compliant JavaScript engine that supports the entire modern JavaScript language spectrum, all while offering unprecedented polyglot capabilities.

What is GraalJS?

GraalJS is an implementation of JavaScript built on the GraalVM stack. It's not just another embedded engine; it's a fundamental part of GraalVM's vision for a polyglot runtime. Key characteristics:

• Built on Truffle: Utilizes the Truffle Language Implementation Framework, which allows for powerful AST interpretation and optimization.
• JIT-Optimized: Leverages the Graal compiler to achieve performance that often rivals or surpasses Node.js for pure JavaScript execution.
• Fully Modern: Implements ECMAScript 2023 and beyond, with support for features like async/await, classes, modules, and more.
• Polyglot by Design: Can interoperate seamlessly with other Truffle languages (Python, R, Ruby, LLVM) within the same runtime.

Architecture: Why GraalJS is Different

The power of GraalJS comes from its unique architecture within the GraalVM ecosystem, which enables unprecedented performance and interoperability:

graph TB
subgraph "GraalVM Runtime"
A[Java Application]
B[GraalJS Engine]
C[Graal Compiler]
D[Polyglot API]
subgraph "Truffle Languages"
E[JavaScript]
F[Python]
G[R]
H[Ruby]
I[Java]
end
A --> D
B --> E
D --> E
D --> F
D --> G
D --> H
D --> I
E --> C
F --> C
G --> C
end
style E fill:#f9f,stroke:#333,stroke-width:2px
style C fill:#ccf,stroke:#333,stroke-width:2px

Getting Started: Basic Integration

1. Dependencies

For GraalVM users, GraalJS is included. For other JDKs, add the dependency:

<!-- Maven -->
<dependency>
<groupId>org.graalvm.polyglot</groupId>
<artifactId>polyglot</artifactId>
<version>23.1.0</version>
</dependency>
<dependency>
<groupId>org.graalvm.polyglot</groupId>
<artifactId>js</artifactId>
<version>23.1.0</version>
<type>pom</type>
</dependency>

2. Basic JavaScript Execution

import org.graalvm.polyglot.*;
public class BasicGraalJS {
public static void main(String[] args) {
try (Context context = Context.create()) {
// Execute simple JavaScript
Value result = context.eval("js", 
"const message = 'Hello from JavaScript';" +
"message.toUpperCase();"
);
System.out.println(result.asString()); // HELLO FROM JAVASCRIPT
// Evaluate expressions with return values
Value sum = context.eval("js", "2 + 3 * 4");
System.out.println("Result: " + sum.asInt()); // Result: 14
// Work with JavaScript objects
Value jsObject = context.eval("js", 
"({ name: 'Alice', age: 30, hobbies: ['reading', 'coding'] })"
);
System.out.println("Name: " + jsObject.getMember("name").asString());
System.out.println("First hobby: " + 
jsObject.getMember("hobbies").getArrayElement(0).asString());
}
}
}

Advanced JavaScript Features

1. Modern ES2023+ Features

try (Context context = Context.create()) {
// ES6+ features fully supported
String modernJS = """
// Array spreading and destructuring
const parts = [1, 2];
const numbers = [...parts, 3, 4];
const [first, ...rest] = numbers;
// Arrow functions and template literals
const greet = (name) => `Hello, ${name}!`;
// Classes and modules
class Person {
constructor(name) { this.name = name; }
speak() { return `${this.name} is speaking`; }
}
// Async/Await
const fetchData = async () => {
return new Promise(resolve => 
setTimeout(() => resolve('Data loaded'), 100)
);
};
// Return multiple values
{ first: first, rest: rest, greeting: greet('Alice'), 
person: new Person('Bob'), fetchData: fetchData }
""";
Value result = context.eval("js", modernJS);
System.out.println("First: " + result.getMember("first").asInt());
System.out.println("Rest length: " + result.getMember("rest").getArraySize());
System.out.println("Greeting: " + result.getMember("greeting").asString());
System.out.println("Person: " + result.getMember("person").invokeMember("speak").asString());
// Execute async function
Value promise = result.getMember("fetchData").execute();
promise.await(); // Wait for promise resolution
System.out.println("Async result: " + promise.asString());
}

2. Java and JavaScript Interoperability

The true power emerges when Java and JavaScript call each other seamlessly:

try (Context context = Context.create()) {
// Expose Java objects to JavaScript
context.getBindings("js").putMember("javaMath", Math.class);
context.getBindings("js").putMember("javaList", Arrays.asList("A", "B", "C"));
// JavaScript can call Java methods
String jsCode = """
// Call static Java method
const random = javaMath.random();
// Call instance methods on Java objects
const size = javaList.size();
const firstElement = javaList.get(0);
// Create Java arrays
const javaArray = Java.type('int[]');
const array = new javaArray(3);
array[0] = 42;
{ random: random, size: size, first: firstElement, array: array }
""";
Value result = context.eval("js", jsCode);
System.out.println("Random from Java: " + result.getMember("random").asDouble());
System.out.println("List size from Java: " + result.getMember("size").asInt());
// Call JavaScript functions from Java
Value jsFunction = context.eval("js", 
"(function(x, y) { return x * y + javaMath.sqrt(x); })"
);
Value functionResult = jsFunction.execute(16, 3);
System.out.println("JavaScript function result: " + functionResult.asDouble());
}

Real-World Use Cases

1. Rules Engine with JavaScript

public class JavaScriptRulesEngine {
private final Context context;
public JavaScriptRulesEngine() {
this.context = Context.create();
// Pre-load utility functions
context.eval("js", """
function evaluateDiscount(customer, orderTotal) {
if (customer.status === 'GOLD' && orderTotal > 1000) {
return orderTotal * 0.15; // 15% discount
} else if (customer.status === 'SILVER' && orderTotal > 500) {
return orderTotal * 0.10; // 10% discount
} else if (orderTotal > 2000) {
return orderTotal * 0.05; // 5% bulk discount
}
return 0;
}
function validateOrder(order) {
const errors = [];
if (!order.items || order.items.length === 0) {
errors.push('Order must contain items');
}
if (order.total < 0) {
errors.push('Total cannot be negative');
}
return errors;
}
""");
}
public double calculateDiscount(Map<String, Object> customer, double orderTotal) {
context.getBindings("js").putMember("customer", customer);
context.getBindings("js").putMember("orderTotal", orderTotal);
Value discount = context.eval("js", "evaluateDiscount(customer, orderTotal)");
return discount.asDouble();
}
public List<String> validateOrder(Map<String, Object> order) {
context.getBindings("js").putMember("order", order);
Value errors = context.eval("js", "validateOrder(order)");
return errors.as(List.class);
}
}

2. Template Processing

public class JavaScriptTemplateEngine {
private final Context context;
public JavaScriptTemplateEngine() {
this.context = Context.create();
// Load template processing library (conceptual)
context.eval("js", """
function renderTemplate(template, data) {
return template.replace(/\\$\\{([^}]+)\\}/g, (match, key) => {
return data[key] !== undefined ? data[key] : match;
});
}
function processArray(items, template) {
return items.map(item => renderTemplate(template, item)).join('');
}
""");
}
public String render(String template, Map<String, Object> data) {
context.getBindings("js").putMember("template", template);
context.getBindings("js").putMember("data", data);
Value result = context.eval("js", "renderTemplate(template, data)");
return result.asString();
}
}
// Usage
JavaScriptTemplateEngine engine = new JavaScriptTemplateEngine();
String template = "Hello, ${name}! Your order ${orderId} is ${status}.";
Map<String, Object> data = Map.of(
"name", "Alice",
"orderId", "ORD-12345",
"status", "shipped"
);
String result = engine.render(template, data);
// Hello, Alice! Your order ORD-12345 is shipped.

Performance Considerations and Best Practices

1. Context Reuse

// ✅ Good: Reuse context (expensive to create)
public class JavaScriptService {
private final Context context;
public JavaScriptService() {
this.context = Context.newBuilder("js")
.allowAllAccess(true) // Be careful with this in production!
.build();
}
public void close() {
context.close();
}
}
// ❌ Bad: Creating context for every execution
public void inefficientCall() {
try (Context context = Context.create()) { // Expensive!
context.eval("js", "someFunction()");
}
}

2. Value Caching and Type Handling

try (Context context = Context.create()) {
// Cache frequently used JavaScript functions
Value cachedFunction = context.eval("js", 
"(function(x) { return x * x + Math.sqrt(x); })"
);
// Reuse the same function instance
for (int i = 0; i < 1000; i++) {
double result = cachedFunction.execute(i).asDouble();
// Process result
}
// Efficient type conversion
Value jsArray = context.eval("js", "[1, 2, 3, 4, 5]");
// Convert to Java array efficiently
int[] javaArray = jsArray.as(int[].class);
// Or work with it as Value for better performance
int sum = 0;
for (int i = 0; i < jsArray.getArraySize(); i++) {
sum += jsArray.getArrayElement(i).asInt();
}
}

Comparison with Alternatives

Conclusion

GraalJS represents a quantum leap for JavaScript execution on the JVM. It's not merely a replacement for Nashorn but a fundamentally more powerful technology that:

• Supports the entire modern JavaScript ecosystem with full ES2023+ compliance
• Delivers exceptional performance through GraalVM's advanced JIT compilation
• Enables true polyglot applications that can seamlessly blend JavaScript, Java, Python, and more
• Provides rich interoperability that makes Java/JavaScript integration feel natural

For Java applications that need rules engines, template processing, plugin systems, or any form of dynamic scripting, GraalJS offers a future-proof solution that combines the flexibility of JavaScript with the robustness of the JVM ecosystem. It transforms JavaScript from being merely "embedded" to being a fully integrated, high-performance component of your Java applications.