OpenJDK is the open-source reference implementation of the Java SE specification. Adoptium (formerly AdoptOpenJDK) is a community-driven project under the Eclipse Foundation that takes OpenJDK source code, builds it, tests it extensively, and distributes production-ready binaries called Eclipse Temurin. Think of OpenJDK as the upstream source and Adoptium as a curated, thoroughly tested distribution of that source.

The practical difference matters when you are choosing which JDK to install on your CI servers, developer machines, or production containers.

What OpenJDK Actually Is

OpenJDK is the official open-source project where the Java SE platform is developed. Oracle leads the project, but contributions come from Red Hat, SAP, Amazon, Microsoft, Azul, and many individual developers. The OpenJDK project produces source code, not downloadable binaries for end users (though Oracle does publish builds from the same source).

Key characteristics of OpenJDK:

• Licensed under GPLv2 with Classpath Exception (GPLv2+CPE), which allows linking without requiring your application to be GPL
• Serves as the Technology Compatibility Kit (TCK) reference, meaning all other Java distributions must pass the same compliance tests
• Releases follow a six-month cadence (Java 17, 18, 19, etc.), with Long-Term Support (LTS) versions every two years
• Oracle provides OpenJDK builds at jdk.java.net, but these only receive updates for six months after each release

1# Installing OpenJDK on Ubuntu
2sudo apt install openjdk-21-jdk
3
4# Verifying the installation
5java -version
6# openjdk version "21.0.2" 2024-01-16
7# OpenJDK Runtime Environment (build 21.0.2+13-Ubuntu-1)

The gap OpenJDK leaves is in long-term binary support. If you install OpenJDK 21 from Oracle's builds, you stop receiving updates when OpenJDK 22 ships six months later. This is where downstream distributors fill the void.

What Adoptium/Eclipse Temurin Is

The AdoptOpenJDK project started in 2017 to solve a specific problem: there was no vendor-neutral, community-driven source of well-tested, free OpenJDK binaries with long-term update support. In 2021, the project moved to the Eclipse Foundation and was renamed Eclipse Adoptium. The binaries it produces are now called Eclipse Temurin.

Adoptium takes the OpenJDK source code, applies its own build and test infrastructure, and publishes binaries for Windows, macOS, Linux (multiple architectures), and Alpine Linux.

1# Installing Temurin via SDKMAN
2sdk install java 21.0.2-tem
3
4# Or via Homebrew on macOS
5brew install --cask temurin@21
6
7# Verifying
8java -version
9# openjdk version "21.0.2" 2024-01-16 LTS
10# OpenJDK Runtime Environment Temurin-21.0.2+13 (build 21.0.2+13)

The AQAvit Test Suite

What distinguishes Temurin from a raw OpenJDK build is the testing. Adoptium runs the AQAvit (Adoptium Quality Assurance) test suite, which includes:

• OpenJDK regression tests (jtreg)
• System-level tests (load, concurrency, stress)
• Application-level tests (running real frameworks like Spring, Tomcat, and Eclipse IDE)
• Performance benchmarks
• Security vulnerability scanning

Any build that passes AQAvit is marked as verified. This level of testing goes beyond what the OpenJDK project itself mandates.

Comparison Table

Other OpenJDK Distributions

Adoptium is not the only downstream distribution. Understanding the landscape helps explain why Adoptium exists and where it fits.

1OpenJDK Source Code
2    |
3    +-- Oracle JDK (commercial license, extended support)
4    +-- Eclipse Temurin (Adoptium, free, AQAvit tested)
5    +-- Amazon Corretto (free, optimized for AWS)
6    +-- Azul Zulu (free community edition, paid enterprise)
7    +-- Red Hat build of OpenJDK (bundled with RHEL)
8    +-- Microsoft Build of OpenJDK (optimized for Azure)
9    +-- SAP Machine (optimized for SAP workloads)
10    +-- BellSoft Liberica (supports more platforms)

All of these start from the same OpenJDK source. The differences are in testing rigor, update frequency, supported platforms, and whether commercial support is available.

Choosing Between Them

Choose OpenJDK (Oracle builds) when:

• You always want the latest release and do not need LTS updates beyond six months
• You are contributing to or debugging the OpenJDK project itself
• Your organization has an Oracle Java SE subscription for commercial support

Choose Adoptium / Eclipse Temurin when:

• You need free, long-term updates for LTS releases (Java 11, 17, 21)
• You want a vendor-neutral distribution not tied to a single cloud provider
• You need pre-built Docker images (the eclipse-temurin images are among the most popular JDK images on Docker Hub)
• Your CI/CD pipeline requires reproducible, well-tested JDK builds across multiple platforms
• You want to standardize on a single distribution across dev, staging, and production

Migration Between Distributions

Switching between OpenJDK distributions is straightforward because they all implement the same specification.

1# Check current JDK
2java -version
3
4# Switch with SDKMAN
5sdk use java 21.0.2-tem    # Temurin
6sdk use java 21.0.2-amzn   # Corretto
7sdk use java 21.0.2-zulu   # Azul Zulu
8
9# In a Dockerfile
10FROM eclipse-temurin:21-jre-alpine
11COPY target/app.jar /app.jar
12ENTRYPOINT ["java", "-jar", "/app.jar"]

No code changes are required. The bytecode, classpath, and module system work identically. The only potential differences are in JVM flags specific to certain distributions (e.g., Corretto's crypto patches or Azul's Zing garbage collector), but these are opt-in.

Common Pitfalls

• Confusing OpenJDK the project with OpenJDK the binary. The project is the source code repository. The binary you download could come from Oracle, Adoptium, Amazon, or any other vendor. Always verify the provenance of your JDK.
• Assuming Oracle JDK is still required for production. Since Java 11, Oracle JDK and OpenJDK are functionally identical. The paid Oracle JDK adds commercial features like Java Flight Recorder support contracts, but Temurin includes JFR as well.
• Not pinning JDK versions in CI/CD. Different runners may have different default JDKs. Pin the exact distribution and version in your pipeline configuration.
• Ignoring update cadence for LTS releases. Oracle's free OpenJDK builds stop receiving patches after six months. If you are on an LTS release, use a distribution like Temurin that backports security fixes for years.
• Mixing distributions in one project. While technically compatible, mixing distributions across environments can make debugging harder. Standardize on one.

Summary

OpenJDK is the source code project that defines the Java platform. Adoptium (Eclipse Temurin) is a downstream distribution that builds, tests, and packages OpenJDK binaries for production use. Both use the same source code and the same GPLv2+CPE license. The practical differences are in testing depth (AQAvit), update longevity (years of LTS patches), platform coverage (including Docker images and ARM builds), and community governance (vendor-neutral Eclipse Foundation). For most teams that want a free, well-tested, long-term-supported JDK without vendor lock-in, Adoptium/Temurin is the pragmatic default choice.