graalvm-ce-builds

GraalVM CE binaires built by the GraalVM community

1,560

122

1,560

View on GitHub

Top Related Projects

graal

20,301

GraalVM compiles Java applications into native executables that start instantly, scale fast, and use fewer compute resources 🚀

graaljs

1,792

A high-performance, ECMAScript compliant, and embeddable JavaScript runtime for Java

Eclipse OpenJ9: A Java Virtual Machine for OpenJDK that's optimized for small footprint, fast start-up, and high throughput. Builds on Eclipse OMR (https://github.com/eclipse/omr) and combines with the Extensions for OpenJDK for OpenJ9 repo.

temurin-build

1,022

Eclipse Temurin™ build scripts - common across all releases/versions

Quick Overview

GraalVM Community Edition (CE) Builds is a repository containing pre-built binaries of GraalVM CE, a high-performance runtime for Java and other languages. It provides a universal virtual machine for running applications written in JavaScript, Python, Ruby, R, JVM-based languages like Java, Scala, Kotlin, and LLVM-based languages such as C and C++.

Pros

Improved performance for Java applications through advanced optimizations
Polyglot programming support, allowing seamless integration of multiple languages
Native image compilation for faster startup and reduced memory footprint
Extensive tooling support, including debuggers and profilers

Cons

Larger download size compared to standard JDK distributions
Some features may require additional configuration or have limitations
Learning curve for utilizing advanced features and optimizations
Potential compatibility issues with certain Java libraries or frameworks

Getting Started

To get started with GraalVM CE:

Visit the releases page and download the appropriate version for your operating system and architecture.
Extract the downloaded archive to your desired location.
Set the JAVA_HOME environment variable to the extracted GraalVM directory.
Add $JAVA_HOME/bin to your system's PATH.

You can now use GraalVM as your Java runtime:

java -version

To install additional languages or tools:

gu install native-image
gu install python

For more detailed instructions and documentation, visit the GraalVM website.

Competitor Comparisons

graal

20,301

GraalVM compiles Java applications into native executables that start instantly, scale fast, and use fewer compute resources 🚀

Pros of graal

More comprehensive codebase, including core GraalVM components
Offers deeper insights into GraalVM internals and development
Provides access to cutting-edge features and experimental implementations

Cons of graal

Larger repository size, potentially more complex to navigate
May include unstable or work-in-progress features
Requires more technical expertise to understand and contribute

Code Comparison

graal:

@Snippet
protected static void writeBarrier(Object object) {
    final Word thread = registerAsWord(THREAD_REGISTER);
    final Word field = Word.unsigned(object);
    writeBarrier(thread, field);
}

graalvm-ce-builds:

#!/usr/bin/env bash
set -e

if [[ "$OSTYPE" == "darwin"* ]]; then
    SCRIPT_HOME="$(cd "$(dirname "$0")" && pwd -P)"

The code snippets highlight the difference in focus between the repositories. graal contains core Java implementation details, while graalvm-ce-builds primarily consists of build scripts and configuration files for creating GraalVM Community Edition distributions.

graaljs

1,792

A high-performance, ECMAScript compliant, and embeddable JavaScript runtime for Java

Pros of graaljs

Focused specifically on JavaScript implementation for GraalVM
Lighter weight and more modular for projects only needing JavaScript support
Potentially faster updates and releases for JavaScript-specific features

Cons of graaljs

Limited to JavaScript functionality, lacking other language support
Requires additional components for full GraalVM capabilities
May have less community support compared to the full GraalVM project

Code Comparison

graalvm-ce-builds:

import org.graalvm.polyglot.*;

public class Example {
    public static void main(String[] args) {
        Context context = Context.create("js");
        Value result = context.eval("js", "40 + 2");
        System.out.println(result.asInt());
    }
}

graaljs:

const Graal = require('graal');

Graal.runScript('js', `
    console.log('Hello from GraalJS!');
    console.log(40 + 2);
`);

Note: The code examples are simplified and may not reflect the exact usage in each project. The graaljs example assumes a hypothetical Node.js integration.

openj9

3,274

Pros of OpenJ9

Lower memory footprint and faster startup times
Better performance in cloud and containerized environments
Advanced garbage collection algorithms optimized for server-side applications

Cons of OpenJ9

Smaller community and ecosystem compared to GraalVM
Less extensive documentation and learning resources
Limited support for ahead-of-time compilation features

Code Comparison

OpenJ9 (JITServer example):

-XX:+UseJITServer
-XX:JITServerAddress=<host>
-XX:JITServerPort=<port>

GraalVM (Native Image example):

native-image --no-fallback -H:+ReportExceptionStackTraces -H:+AddAllCharsets --allow-incomplete-classpath --report-unsupported-elements-at-runtime --initialize-at-build-time=org.example.SomeClass MyApplication

Both projects aim to improve Java performance, but they take different approaches. OpenJ9 focuses on optimizing runtime performance and memory usage, while GraalVM emphasizes ahead-of-time compilation and polyglot capabilities. The choice between them depends on specific project requirements and deployment environments.

temurin-build

1,022

Eclipse Temurin™ build scripts - common across all releases/versions

Pros of Temurin-build

Wider platform support, including AIX and more ARM variants
More frequent releases and updates
Stronger focus on long-term support (LTS) versions

Cons of Temurin-build

Lacks advanced features like ahead-of-time compilation and polyglot programming
May have slightly lower performance in certain scenarios
Does not include a native image compiler

Code Comparison

GraalVM CE Builds:

@Substitution
Target_java_lang_System_getenv(String name) {
    return VmImpl.getenv(name);
}

Temurin-build:

public static String getenv(String name) {
    SecurityManager sm = getSecurityManager();
    if (sm != null) {
        sm.checkPermission(new RuntimePermission("getenv."+name));
    }
    return ProcessEnvironment.getenv(name);
}

Both repositories focus on building Java runtimes, but GraalVM CE Builds offers more advanced features for performance optimization and polyglot support. Temurin-build, on the other hand, provides a more traditional Java runtime with broader platform compatibility and a stronger emphasis on long-term support versions. The code comparison shows different approaches to environment variable handling, with GraalVM using substitutions for optimization and Temurin implementing standard Java security checks.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

GraalVM Downloads

This repository hosts GraalVM Community's builds based on OpenJDK.

Additional language runtimes such as Python, Ruby, JavaScript and Node.JS, designed for use with GraalVM, are available for download as standalone distributions in the related repositories.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot