1996 – 2026

Java Versions

Every public release of Java — Java 1.0 in January 1996 through Java 26 in March 2026 — with LTS status, Oracle and third-party end-of-life dates, and the major changes per version. Plus the Sun launch, the JCP, the Oracle acquisition, the API lawsuit, the OpenJDK split, the six-month cadence shift, GraalVM, and virtual threads.

Era & support

Era

Sun — Java 1.0 – 6, 1996–2006, Sun Microsystems stewardship
Oracle pre-cadence — Java 7 – 8, 2011–2014, post-acquisition, still feature-driven
Cadence — Java 9+, 2017 onward, six-month time-boxed line

Support

LTS — Long-Term Support, still inside its Oracle Premier window. Designated every two years since 2021 — every fourth release since Java 17; the 11 → 17 gap was three years
Interim — non-LTS feature release; six months of Oracle public updates
Maintained — LTS past Oracle Premier; vendor builds (Temurin, Corretto, Zulu) still ship updates
EOL — past public update windows from every major distribution

Java version table

Version
Java 26
Cadence
Interim
EOL Sep 2026
Mar 17, 2026
Latest interim. HTTP/3 for the HTTP Client; AOT object caching extended to all GCs; Applet API removed.
  • Standard six-month interim release; six months of Oracle public updates through September 2026.
  • HTTP/3 for the HTTP Client API (JEP 517) — the built-in HttpClient now speaks HTTP/3; no third-party library required.
  • AOT object caching with any GC (JEP 516) — extends the ahead-of-time cache introduced in Java 24 to work alongside ZGC and other GCs, not just G1.
  • Applet API removed (JEP 504) — the in-browser Java story is formally over; the Applet API was deprecated in Java 9 and marked for removal in Java 17.
  • Prepare to Make Final Mean Final (JEP 500) — warnings issued when code mutates final fields through reflection; groundwork for eventual enforcement.
  • G1 GC throughput improvement via reduced synchronization (JEP 522).
  • Primitive types in patterns, instanceof, and switch in fourth preview (JEP 530); structured concurrency sixth preview (JEP 525); lazy constants second preview (JEP 526); PEM encoding API second preview (JEP 524); Vector API eleventh incubator (JEP 529).
Version
Java 25
Cadence
LTS
Premier Sep 2030
Sep 16, 2025
Current LTS. Successor to Java 21. Compact source files, scoped values, module imports; 32-bit x86 port removed.
  • Long-Term Support release. Oracle Premier through September 2030; Extended Support through September 2033 for paying customers. Adoptium Temurin and Amazon Corretto both carry free public updates past Oracle Premier — Temurin 25 to at least September 2031, Corretto 25 to October 2032.
  • Compact source files and instance main methods graduate — the on-ramp script-style entry-point work that started in Java 21 / 22 (JEP 512 lineage).
  • Scoped values reaches stable status — the structured replacement for ThreadLocal in Loom-shaped code.
  • Module import declarations (JEP 511) and the Key Derivation Function API (JEP 510) graduated; compact object headers (JEP 519) and generational Shenandoah (JEP 521) reached production after an experimental run in Java 24.
  • The 32-bit x86 port was removed (JEP 503). The Windows half had already gone in Java 24 (JEP 479); this release took the rest. There is no 32-bit build of Java 25 or later.
  • Primitive types in patterns, instanceof, and switch reached a third preview (JEP 507); structured concurrency a fifth (JEP 505).
  • The default LTS for new production work in 2026 onward; replaces Java 21 in that role for projects with the appetite to upgrade.
Version
Java 24
Cadence
EOL
Sep 2025
Mar 18, 2025
Stream gatherers final; ahead-of-time class loading and linking; quantum-resistant crypto.
  • Interim release; reached EOL when Java 25 LTS shipped.
  • Stream gatherers graduated to stable — user-defined intermediate stream operations in Stream.gather().
  • Ahead-of-time class loading and linking (JEP 483) — record class metadata at training time so cold-start skips classpath scan and bytecode verify.
  • Quantum-resistant cryptography — ML-KEM (key encapsulation) and ML-DSA (digital signatures) added to java.security.
  • Class-File API graduated to stable (JEP 484) — the standard-library replacement for the long-aging ASM bytecode toolkit, after two preview rounds in Java 22 and 23.
  • Compact source files and instance main methods continued in preview.
  • Generational Shenandoah reaches experimental.
  • The Windows 32-bit x86 port was removed (JEP 479), and the remaining 32-bit x86 port deprecated for removal (JEP 501) ahead of its deletion in Java 25.
Version
Java 23
Cadence
EOL
Mar 2025
Sep 17, 2024
Markdown JavaDoc; ZGC generational by default; primitive type patterns (preview).
  • Interim release; reached EOL when Java 24 shipped.
  • Markdown JavaDoc — doc comments can be authored in Markdown using /// instead of HTML in /** */.
  • ZGC generational mode became the default ZGC behavior — the non-generational mode was deprecated for removal.
  • Primitive type patterns in pattern-matching for switch / instanceof entered preview.
  • Class-File API continued in preview — standard library replacement for the long-aging ASM bytecode toolkit.
  • Module import declarations entered first preview (JEP 476) — final in Java 25; flexible constructor bodies continued in preview (JEP 482, second preview).
Version
Java 22
Cadence
EOL
Sep 2024
Mar 19, 2024
Foreign function & memory API final; unnamed variables and patterns final; stream gatherers (preview).
  • Interim release; reached EOL when Java 23 shipped.
  • Foreign function & memory API graduated to stable — the JNI replacement that lets pure-Java code call native code and manage off-heap memory safely. Project Panama's headline deliverable.
  • Unnamed variables and patterns graduated — _ for "I have to declare it but don't care."
  • Stream gatherers entered preview — user-defined intermediate stream operations.
  • Statements before super(…) entered preview — flexible constructor bodies.
  • Region pinning for G1 GC.
Version
Java 21
Cadence
LTS
Premier Sep 2028
Sep 19, 2023
LTS. Virtual threads (Project Loom) final; pattern matching for switch final; record patterns; sequenced collections.
  • Long-Term Support release. Oracle Premier through September 2028; Extended through September 2031 for paying customers. The default Java for production work since 2024.
  • Oracle's free-use window on Java 21 closes September 2026. Oracle JDK 21 has shipped under the No-Fee Terms and Conditions license since 2023, but per the Oracle support roadmap, update releases from the October 2026 Critical Patch Update onward are to be offered under the paid Java SE OTN license — the same terms already covering Java 8, 11, and 17. Oracle's stated advice is to move to JDK 25. The GPL+CE builds from Temurin, Corretto, Zulu, and Microsoft are unaffected.
  • Virtual threads (Project Loom) graduated to stable — structured concurrency that preserves thread-per-request code without thread-per-OS-thread costs. The headline language-platform release of the cadence era.
  • Pattern matching for switch graduated — switch expressions and statements with type patterns and guards.
  • Record patterns graduated — deconstruction in pattern-matching positions.
  • Sequenced collections — SequencedCollection, SequencedSet, SequencedMap with first/last access on every ordered structure.
  • Generational ZGC arrived as an opt-in production mode (JEP 439); it became ZGC's default in Java 23, and the non-generational mode was removed in Java 24 (JEP 490).
  • Foreign function & memory API in third preview; final in Java 22.
  • Deprecated the Windows 32-bit x86 port for removal (JEP 449) — the removal itself landed three releases later in Java 24 (JEP 479), and Java 25 dropped the 32-bit x86 port entirely (JEP 503).
Version
Java 20
Cadence
EOL
Sep 2023
Mar 21, 2023
Scoped values (incubator); continued previews of Loom and Panama.
  • Interim release; reached EOL when Java 21 LTS shipped.
  • Scoped values (incubator) — structured-concurrency-friendly replacement for ThreadLocal.
  • Virtual threads in second preview before Java 21 made them final.
  • Pattern matching for switch in fourth preview.
  • Record patterns in second preview.
  • Foreign function & memory API in second preview.
Version
Java 19
Cadence
EOL
Mar 2023
Sep 20, 2022
Virtual threads (preview); structured concurrency (incubator); pattern matching for switch (third preview).
  • Interim release; reached EOL when Java 20 shipped.
  • Virtual threads (preview) — the first public preview of Project Loom. The release that unlocked the Loom era for early adopters.
  • Structured concurrency (incubator) — treat groups of related tasks as a single unit, with cancellation propagation.
  • Pattern matching for switch in third preview.
  • Record patterns in first preview.
  • Foreign function & memory API in first preview.
Version
Java 18
Cadence
EOL
Sep 2022
Mar 22, 2022
UTF-8 by default; simple web server; internet-address resolution SPI.
  • Interim release; reached EOL when Java 19 shipped.
  • UTF-8 by default — the JVM's default character set is now UTF-8 regardless of locale, the source of countless cross-platform Java surprises since 1996.
  • Simple web server — jwebserver for serving a directory over HTTP for local prototyping.
  • Internet-address resolution SPI for swapping out DNS implementations.
  • Code snippets in JavaDoc {@snippet}.
  • Vector API in third incubator.
Version
Java 17
Cadence
LTS
Premier Sep 2026
Sep 14, 2021
LTS. Sealed classes final; strong encapsulation of JDK internals by default; macOS/AArch64 port; Applet API deprecated for removal.
  • Long-Term Support release. Oracle Premier through September 2026; Extended through September 2029, with Oracle waiving the Extended Support fee for the October 2026 – September 2029 stretch. Was the dominant production target across the industry from 2022 through 2024.
  • Oracle JDK 17 left the free license in October 2024. Update releases from October 15, 2024 onward ship under the paid Java SE OTN license rather than the No-Fee Terms and Conditions. Free public updates continue from Temurin, Corretto, Zulu, and Microsoft under GPL+CE.
  • Sealed classes graduated — restrict which classes may extend a class or implement an interface, enabling exhaustive pattern matching.
  • Pattern matching for switch entered first preview (JEP 406) — type patterns and guards in switch, final in Java 21. Pattern matching for instanceof had already graduated a release earlier, in Java 16.
  • Strong encapsulation of JDK internals by default (JEP 403) — the --illegal-access command-line flag was made obsolete and ignored; libraries depending on sun.* internals must use the --add-opens escape hatch explicitly.
  • Applet API deprecated for removal (JEP 398) — the in-browser Java story was formally wound down here; the actual removal landed four and a half years later in Java 26 (JEP 504).
  • Foreign function & memory API in incubator (Project Panama).
  • macOS / AArch64 port (Apple Silicon) reached production.
  • New Random generator interfaces — RandomGenerator, RandomGeneratorFactory.
Version
Java 16
Cadence
EOL
Sep 2021
Mar 16, 2021
Records final; pattern matching for instanceof final; Vector API (incubator); migrated source code to Git/GitHub.
  • Interim release; reached EOL when Java 17 LTS shipped.
  • Records graduated to stable — concise immutable data carriers, the tracker's headline syntax addition since lambdas.
  • Pattern matching for instanceof graduated — later worked together with sealed classes (Java 17) to enable exhaustive switch.
  • Vector API (first incubator) — SIMD intrinsics from Java code; precursor to the modern Panama vector work.
  • Strong encapsulation of JDK internals by default for most packages, with --illegal-access=warn still available; the final hammer fell in Java 17.
  • OpenJDK source migrated from Mercurial to Git/GitHub — an end-of-an-era move for one of the longest-running Mercurial repos.
Version
Java 15
Cadence
EOL
Mar 2021
Sep 15, 2020
Sealed classes (preview); text blocks final; ZGC and Shenandoah GC reach production; hidden classes.
  • Interim release.
  • Sealed classes in first preview.
  • Text blocks graduated — multiline string literals with """.
  • ZGC reached production-ready status — sub-millisecond pause times on multi-terabyte heaps.
  • Shenandoah reached production — concurrent low-pause GC originally from Red Hat.
  • Hidden classes — runtime-loaded classes that aren't visible to other classes (used by frameworks, lambda metafactory).
  • Edwards-Curve digital signature algorithm (EdDSA).
Version
Java 14
Cadence
EOL
Sep 2020
Mar 17, 2020
Records (preview); pattern matching for instanceof (preview); switch expressions final; helpful NullPointerExceptions.
  • Interim release.
  • Records in first preview.
  • Pattern matching for instanceof in first preview.
  • Switch expressions graduated to stable.
  • Helpful NullPointerExceptions — the runtime now identifies which dereferenced reference was null in a chain like a.b().c, ending two decades of mystery NPEs.
  • Foreign-Memory Access API (incubator) — Project Panama's first preview surface.
  • JFR Event Streaming for continuous monitoring.
Version
Java 13
Cadence
EOL
Mar 2020
Sep 17, 2019
Text blocks (preview); switch expressions (second preview); reimplementation of legacy Socket API.
  • Interim release.
  • Text blocks in first preview — the multiline string literal that landed final in Java 15.
  • Switch expressions in second preview.
  • Reimplementation of the legacy Socket / ServerSocket API on top of NIO — finally retiring 1996-era code.
  • ZGC continued maturing on more platforms.
Version
Java 12
Cadence
EOL
Sep 2019
Mar 19, 2019
Switch expressions (preview); Shenandoah GC (experimental); microbenchmark suite.
  • Interim release.
  • Switch expressions in first preview — the syntax that eventually unlocked pattern matching for switch.
  • Shenandoah GC entered the OpenJDK as experimental.
  • JVM Constants API.
  • Microbenchmark suite (JMH) integrated with the JDK source.
Version
Java 11
Cadence
Maintained
vendor builds
Sep 25, 2018
First cadence-era LTS. HTTP Client final; Files.readString; ZGC (experimental); Java EE / CORBA modules removed.
  • First Long-Term Support release of the cadence era. Oracle Premier Support ended September 2023; Oracle Extended Support continues through January 2032 for paying customers. Adoptium Temurin and Amazon Corretto continue to ship free public updates — Corretto 11 is committed through January 2032 at minimum.
  • The HTTP Client (java.net.http.HttpClient) graduated to stable — HTTP/2 and WebSocket support in the standard library, replacing HttpURLConnection for new code.
  • Files.readString / Files.writeString — a long-overdue convenience.
  • ZGC entered the JDK as experimental.
  • Epsilon GC — "no-op" garbage collector for benchmarking and short-lived workloads.
  • Removed Java EE and CORBA modules — java.xml.ws, java.xml.bind, java.activation, java.corba all dropped from the JDK; libraries that needed JAXB or JAX-WS had to add explicit dependencies.
  • Single-file source-code launch — java HelloWorld.java runs without an explicit javac step.
  • JavaFX unbundled from the JDK and moved to openjfx.io.
Version
Java 10
Cadence
EOL
Sep 2018
Mar 20, 2018
First six-month cadence release. Local-variable type inference (var); G1 parallel full GC.
  • First release shipped on the new six-month cadence promised at Java 9.
  • Local-variable type inference — var x = new ArrayList<String>() for local variables only.
  • Parallel full GC for G1, removing one of G1's longest-standing pause-time complaints.
  • Application class-data sharing — reduce footprint for multiple JVMs on the same machine.
  • Root certificates checked in alongside the JDK source.
Version
Java 9
Cadence
EOL
Mar 2018
Sep 21, 2017
The cadence shift. Modules (Project Jigsaw); JShell; collection factory methods; multi-release JARs.
  • The version that introduced the six-month cadence. Mark Reinhold's "Moving Java forward faster" proposal landed with this release.
  • Modules (Project Jigsaw, JPMS) — the JDK was split into ~75 modules; libraries can declare module boundaries with module-info.java. Three years late from the original 2014 plan, contentious in the community, and the foundation for the strong-encapsulation work that finished in Java 17.
  • JShell — the official Java REPL.
  • Collection factory methods — List.of(…), Map.of(…), Set.of(…) for immutable literals.
  • Private interface methods — private helpers shared by default methods.
  • Multi-release JARs — bundle META-INF/versions/N/ overlays for newer JDKs.
  • Reactive Streams in java.util.concurrent.Flow.
  • Deprecated the Applet API (JEP 289) and the browser deployment stack (Java Plug-in, Java Web Start) — the deployment stack was dropped from the JDK in Java 11, the Applet API not until Java 26. What this release actually removed: launch-time JRE version selection (JEP 231), the jhat tool (JEP 241), and the hprof agent (JEP 240).

The six-month cadence — September 2017. Above this line: the Cadence era — time-boxed releases every March and September, with an LTS designated every two years — every fourth release since Java 17, three years apart before that. Below: the pre-cadence era of multi-year gaps and feature-driven releases. The shift was Mark Reinhold's response to Java 9's three-year delay; the prose section on the cadence shift.

Version
Java 8
Oracle
Maintained
vendor builds
Mar 18, 2014
Lambdas, streams, default methods, Optional, java.time. The single most-deployed Java version of all time.
  • The single most-deployed Java release in history. Twelve years on, still in production at scale at most large enterprises. Oracle Premier ended March 2022; Extended through December 2030 for paying customers. Adoptium Temurin 8 has committed updates through December 2030 at minimum; Amazon Corretto 8 through December 2030.
  • Lambda expressions — the headline language addition; the project (JSR-335) was first proposed in 2009 by Brian Goetz.
  • Streams API — bulk operations on collections with a fluent, lazy, parallel-capable API.
  • Default methods on interfaces — the runtime trick that let Collection grow stream() without breaking every existing implementation.
  • java.time (JSR-310) — Stephen Colebourne's port of Joda-Time; finally retired the 1996-era Date / Calendar mess.
  • Optional<T>; method references; type annotations; repeating annotations.
  • Nashorn JavaScript engine (later removed in Java 15).
  • Compact profiles; PermGen replaced by Metaspace.
  • The release that turned C# vs. Java back into a real conversation.
Version
Java 7
Oracle
EOL
Apr 2015
Jul 28, 2011
First Oracle release. try-with-resources; diamond operator; switch on strings; NIO.2; Fork/Join.
  • First major Java release under Oracle's stewardship after the January 2010 Sun acquisition closed.
  • Oracle's free public updates ended April 2015. Paid support ran well past that — Oracle Premier to July 2019, Extended to July 2022 — and Azul is the outlier still selling Java 7 updates, with a published lifecycle running to December 2029.
  • try-with-resources — deterministic resource cleanup via the AutoCloseable interface.
  • Diamond operator — new HashMap<>() instead of repeating the type parameters.
  • Switch on strings.
  • Multi-catch — catch (IOException | SQLException e).
  • NIO.2 (java.nio.file) — Path, Files, asynchronous I/O. Modern file API at last.
  • Fork/Join framework — the work-stealing executor that underlies parallel streams.
  • InvokeDynamic bytecode — the JVM hook that made dynamic-language implementations and lambdas viable.
  • The release Sun spent 2006–2009 trying to ship; Oracle finished it eighteen months after the acquisition closed.

The Oracle acquisition — closed January 27, 2010. Above this line: the Oracle pre-cadence era — Java 7 and Java 8, Oracle stewardship, still feature-driven multi-year cycles. Below: the Sun era — Java 1.0 through 6, Sun Microsystems' twelve-year run as the platform's steward. The prose section on the acquisition.

Version
Java SE 6
Sun
EOL
Apr 2013
Dec 11, 2006
"Mustang." Scripting (JSR 223), JDBC 4.0, JAX-WS in the JDK, performance and JVM diagnostic work.
  • Codename Mustang. Internal version 1.6; "Java SE 6" was the marketing name. The "1.x" naming continued internally.
  • Scripting in the JVM (javax.script, JSR 223) — the hook for Rhino, later Nashorn, and every JVM-hosted scripting engine.
  • JDBC 4.0; JAX-WS bundled into the JDK; built-in HTTP server (com.sun.net.httpserver).
  • Substantial JVM performance work; JConsole / VisualVM monitoring tools matured.
  • The last major release Sun shipped before Sun v. Microsoft's aftershocks faded and before Oracle bought the company. Java 7 would not ship for another four and a half years.
  • Oracle Premier support ended December 2015 and Extended Support ended December 2018; only indefinite Sustaining Support remains for contract holders. Public free updates from any major distribution have ended.
Version
Java 5 (1.5)
Sun
EOL
Oct 2009
Sep 30, 2004
"Tiger." Generics, annotations, autoboxing, enums, varargs, enhanced for-loop, java.util.concurrent.
  • Codename Tiger. Internal version 1.5; this is the release where Sun first promoted "5.0" as the marketing name — the start of the "use the major number people actually search for" convention.
  • Generics — with type erasure (the controversial design choice that distinguishes Java's generics from C#'s reified ones).
  • Annotations — metadata on classes, methods, fields, parameters; the foundation of Spring, Hibernate, JUnit 4, JAX-RS, every modern Java framework.
  • Autoboxing / unboxing; enums; varargs; the enhanced for-loop; static imports.
  • java.util.concurrent — Doug Lea's concurrency library merged into the JDK, bringing ExecutorService, ConcurrentHashMap, atomics, locks, and the rest of modern Java concurrency.
  • The single largest leap in the language story until Java 8's lambdas.
Version
J2SE 1.4
Sun
EOL
Oct 2008
Feb 6, 2002
"Merlin." assert keyword, java.util.regex, NIO, IPv6, JAXP, Web Start.
  • Codename Merlin. The first Java release developed under the JCP (the Sun-led standards body had been formed in late 1998; this was the first through-the-process release).
  • assert keyword — took six years and a lot of debate.
  • java.util.regex — regex finally in the standard library after years of third-party implementations.
  • NIO — non-blocking I/O, channels, selectors, buffers. The infrastructure under every later high-throughput Java networking library.
  • IPv6 support; Java Web Start; image I/O; XML processing (JAXP, JAXB precursor).
  • Logging API (java.util.logging) — Sun's standard library answer to log4j (which had launched in 1999).
Version
J2SE 1.3
Sun
EOL
Nov 2006
May 8, 2000
"Kestrel." HotSpot JVM as default; JNDI; JavaSound; performance overhaul.
  • Codename Kestrel.
  • HotSpot JVM as default — Sun acquired Animorphic Systems in 1997 for HotSpot; this is the release where adaptive JIT compilation became the standard Java runtime story.
  • JNDI in the core platform; JavaSound; CORBA refinements.
  • Substantial performance work; the era when "Java is slow" started becoming false.
Version
J2SE 1.2 (Java 2)
Sun
EOL
Nov 2003
Dec 8, 1998
"Playground." The "Java 2" rebrand. Swing, Collections framework, JIT default, strictfp.
  • Codename Playground. The "Java 2 Platform" rebrand — "J2SE", "J2EE", "J2ME". This naming would last twelve years until Sun retired it for "Java SE / EE / ME" in Java 6's era.
  • Swing — the long-awaited successor to AWT for desktop UI, with a pluggable look-and-feel architecture.
  • Collections framework — List, Set, Map, the iterators and algorithms in java.util. Joshua Bloch's design; the foundation of every Java codebase since.
  • JIT compiler became the default; strictfp; weak references.
  • Java IDL / CORBA support.
  • The first Java release where the platform felt like a serious enterprise option.
Version
JDK 1.1
Sun
EOL
Apr 2003
Feb 19, 1997
Inner classes, JDBC, RMI, JavaBeans, AWT event-model rewrite, Unicode improvements.
  • Inner classes; reflection API.
  • JDBC for database access; RMI for remote method invocation.
  • JavaBeans component model.
  • AWT event model rewrite — the listener-based design that survived through Java 1.4.
  • Internationalization improvements; broader Unicode support.
  • Released alongside the second Sun-vs-Microsoft front around J/Direct and J++.
Version
JDK 1.0
Sun
EOL
—
Jan 23, 1996
First public release. "Write once, run anywhere." Applets in Netscape; AWT; primitive types and classes.
  • The original public release. Free to download, write-once-run-anywhere bytecode, garbage collection, and applets — which reached a mass audience thirteen days later, when Netscape Navigator 2.0 shipped final on February 5, 1996 with a Java runtime built in.
  • Originally an internal Sun project codenamed Oak, started in 1991 by James Gosling, Mike Sheridan, and Patrick Naughton inside Sun's Green Project. Targeted set-top boxes and consumer electronics. Renamed to Java in 1995 after a trademark conflict.
  • Public preview as "Java alpha" / "HotJava" in May 1995 at SunWorld; final 1.0 in January 1996.
  • AWT for UI; java.lang, java.util, java.io, java.net, java.applet in the core.
  • Single-pass interpreter, no JIT in 1.0 itself — that came with HotSpot in J2SE 1.3 (and earlier with Sun's "JIT" plugin and IBM's J9 line).
  • The release that turned a research project into a platform.

Click any row to expand. Each row has a stable id for sharing — e.g. /software/java/versions/#java-21, #java-8, #java-1-0. LTS support windows for Oracle JDK are documented in the Oracle Java SE Support Roadmap; OpenJDK release dates and JEPs at openjdk.org/projects/jdk.

Distributions — who actually ships your JDK

"Java" is a specification (the JLS and JVMS); "the JDK" is whatever build of OpenJDK you actually install. Several major distributions package the same upstream OpenJDK source under their own license and support windows. The license differences and free-public-update windows are real and load-bearing — they're the reason a Java 8 deployment can still be receiving updates in 2026 even though Oracle stopped shipping free Java 8 updates for commercial use back in 2019.

Distribution Vendor License (free use) LTS free public updates Notes
Oracle JDK
oracle.com/java		 Oracle NFTC on the newest LTS (free for production); older LTS update releases revert to the paid OTN license; GPL+CE for OpenJDK builds Premier 5 yr after each LTS from Java 11 on (Java 8's ran eight); Extended is paid only. Free NFTC updates run until roughly a year after the next LTS ships — Java 17 flipped to the paid OTN license in Oct 2024, Java 21 flips with the Oct 2026 Critical Patch Update, and Oracle has dated Java 25's own flip to after Sep 2028, leaving Java 25 as the current free line The "default" if you go to java.com. NFTC license added in 2021 made Oracle JDK free again for production use after the 2019 paid pivot.
OpenJDK builds
openjdk.org		 Oracle, community GPL v2 + Classpath Exception Six months from each release (cadence) — LTS gets community handoff to other vendors The reference upstream source. Oracle ships official OpenJDK builds for six months per release; longer-term LTS updates continue in the OpenJDK JDK Updates project (the 11, 17, 21, and 25 update trains), with Java 8 maintained by the separate, Red Hat–led JDK 8 Updates project.
Eclipse Temurin
adoptium.net		 Eclipse Foundation (Adoptium) GPL v2 + Classpath Exception 8 through Dec 2030; 11 through Oct 2027; 17 through Oct 2027; 21 through Dec 2029; 25 through Sep 2031 (published roadmap) The "neutral" vendor-agnostic OpenJDK build. Backed by IBM, Microsoft, Red Hat, Azul, and others through the AdoptOpenJDK / Adoptium working group. The most-installed Java in container images.
Amazon Corretto
aws.amazon.com/corretto		 Amazon GPL v2 + Classpath Exception Amazon publishes a fixed end-of-life date per LTS rather than a support duration: Corretto 8 through Dec 2030; 11 through Jan 2032; 17 through Oct 2029; 21 through Oct 2030; 25 through Oct 2032 Free production-grade OpenJDK build with multi-year LTS support. Default JDK on Amazon Linux and most AWS Java workloads. Includes patches Amazon runs internally before they upstream.
Azul Zulu
azul.com/downloads		 Azul Systems Azul Zulu Builds of OpenJDK are GPL+CE; the Azul Core and Azul Prime subscriptions are paid Free Zulu builds follow each LTS train; Azul Core's published lifecycle is at least 8 yr production support plus 2 yr extended per LTS (8 to Dec 2030, 11 to Jan 2032, 17 to Sep 2029, 21 to Sep 2031, 25 to Sep 2033) Long-running independent JDK vendor, wholly focused on Java and the JVM. The free Zulu builds are TCK-certified; the paid Azul Prime tier (formerly Zulu Prime / Zing) ships the C4 pauseless collector, the Falcon JIT, and ReadyNow warm-up.
Microsoft Build of OpenJDK
learn.microsoft.com/java/openjdk		 Microsoft GPL v2 + Classpath Exception 11 and 17 through Sep 2027; 21 through Sep 2028; 25 through Sep 2030 (Microsoft's own published roadmap) Microsoft's own free OpenJDK build, started in 2021. Default in Azure Java workloads and many Microsoft developer tools. Microsoft publishes its own earliest-end-of-support dates rather than adopting Adoptium's, so its windows are close to — but not identical with — Temurin's.
Red Hat OpenJDK
developers.redhat.com/products/openjdk		 Red Hat (IBM) GPL v2 + Classpath Exception Full Support runs to a per-version date pinned to the underlying RHEL lifecycle rather than a fixed duration, then a paid Extended Life Cycle Support (ELS-1) phase: 8 through Nov 2026 (ELS to Dec 2032); 11 ended Oct 2024 (ELS to Jan 2032); 17 through Dec 2027 (ELS to Jan 2029); 21 through Dec 2029 (ELS to Sep 2031); 25 through Dec 2030 (ELS to Sep 2033) Red Hat took stewardship of the upstream OpenJDK 8 and OpenJDK 11 update projects from Oracle in 2019 and still leads JDK 8 Updates; the 11, 17, 21, and 25 update trains now sit inside the Oracle-led JDK Updates project. The default Java for RHEL.
IBM Semeru
developer.ibm.com/languages/java/semeru-runtimes		 IBM GPL+CE for OpenJDK; Eclipse OpenJ9 under EPL 2.0 / Apache 2.0 8 through Dec 2030; 11 and 17 through Oct 2027; 21 through Dec 2029; 25 tracks upstream OpenJDK end-of-service in Sep 2030, with IBM's own end-of-availability date still TBD (IBM's published support dates) The OpenJDK build that ships the Eclipse OpenJ9 JVM instead of HotSpot. Lower memory footprint, the basis of IBM's J9 line for thirty years.
GraalVM CE / Oracle GraalVM
graalvm.org		 Oracle Labs GPL v2 + Classpath Exception (Community Edition); GFTC for Oracle GraalVM Quarterly CPU updates on the JDK LTS lines (17, 21, 25); monthly feature releases since 25.1. CE is free. An alternative JIT and a native-image AOT compiler — native-image produces standalone executables with sub-100ms cold start. The Java answer to Go/Rust deployment ergonomics.

License acronyms: GPL+CE = GNU General Public License v2 with the OpenJDK Classpath Exception (the standard OpenJDK license; safe for proprietary applications); NFTC = Oracle's No-Fee Terms and Conditions license, introduced with Java 17 in 2021 and refined since — production use is free and redistribution restrictions apply, but Oracle keeps only the newest LTS on these terms and moves each older LTS's update releases to the paid Java SE OTN license about a year after its successor ships; GFTC = the GraalVM Free Terms and Conditions, the license Oracle has applied to Oracle GraalVM since June 2023, beginning with the GraalVM for JDK 17 builds — free for any user including commercial and production use, with redistribution permitted only when not for a fee.

The 1995 launch and Sun Microsystems

Java started as the Green Project inside Sun Microsystems in December 1990, led by James Gosling, Mike Sheridan, and Patrick Naughton. The brief: design a programming environment for next-generation consumer electronics — set-top boxes, interactive television, smart appliances — that would survive the multi-decade life of consumer hardware. Gosling's first cut was a language called Oak, named after a tree outside his office window.

The set-top box market never materialized. By 1994 the team had repurposed the runtime for the emerging World Wide Web, betting that small bytecode-compiled "applets" embedded in HTML pages would be Java's killer app. The HotJava browser, released in May 1995, demonstrated the idea. Java 1.0 went GA on January 23, 1996, and Netscape Navigator 2.0 — the first mass-market browser to run Java applets — shipped final on February 5, 1996. Navigator's dates collapse easily, and three of them are separate events: Netscape introduced the browser on September 18, 1995, but that day's press release puts the download in the future — a public beta "will be available next week." The betas that carried Java came later still, on October 10, 1995, and then only as the b1J build for Windows 95, Solaris and IRIX — the Windows 3.1, Macintosh and other UNIX betas were posted without Java. The final release is what put a Java runtime on ordinary desktops, and it is the moment Java became real to the industry.

"Write once, run anywhere" became Sun's tagline and a generational positioning bet against Microsoft's Win32. The intermediate Java bytecode abstraction, JIT compilation, and a managed memory model were the mechanisms; the real product was platform independence at a moment when "your Mac couldn't run your dad's PC software" was a structural fact. Java's ascent paralleled Linux's, and not by accident — both bet on platform-independence in the era when Microsoft's Win32 lock-in looked permanent.

The Java Community Process

The Java Community Process (JCP) was established by Sun in December 1998 as the formal mechanism for evolving the Java specification. Specifications became JSRs (Java Specification Requests); each JSR went through community review with a designated Expert Group. Sun retained final authority through the spec lead role on every Java SE JSR.

Notable JSRs over the years: JSR 14 (Generics, eventually shipped in Java 5), JSR 175 (Annotations), JSR 220 (EJB 3.0), JSR 310 (the new date/time API in Java 8), JSR 335 (Lambdas in Java 8), JSR 376 (Modules in Java 9). After Oracle's acquisition, Java SE moved most of its evolution into JEPs (JDK Enhancement Proposals) on OpenJDK, with the JCP continuing to formally bless the Java SE specification post-fact. Java EE evolution moved out of the JCP entirely with the Eclipse Foundation handoff in 2017 (see "Jakarta EE" below).

Sun v. Microsoft (1997–2001)

Microsoft licensed Java from Sun in March 1996 and shipped its own Java implementation in Windows. The licensed implementation diverged: Microsoft added Windows-specific extensions (J/Direct, RNI) and omitted parts of the Java spec required for portability. Sun sued in October 1997, alleging breach of the license agreement and unfair business practices. After a preliminary injunction in November 1998 and several years of litigation, the case settled in January 2001; Microsoft agreed to pay $20 million and stopped distributing its Java implementation in Windows. A separate antitrust settlement in 2004 had Microsoft pay an additional $1.6 billion.

The episode is the reason Microsoft pivoted to creating its own competing platform — .NET, announced in mid-2000 and shipping as 1.0 in February 2002 — rather than continuing to license Java. The C# language explicitly took inspiration from Java while diverging on generics (reified instead of erased), value types, properties, and other features Anders Hejlsberg had been advocating for at Borland. (Cross-link: .NET Versions.)

The Oracle acquisition (April 2009 / January 2010)

Oracle announced its acquisition of Sun Microsystems for $7.4 billion on April 20, 2009. The deal closed January 27, 2010 after EU competition review. Oracle inherited Java, Solaris, ZFS, MySQL (Sun had bought MySQL AB the year before), and Sun's hardware business. For Java specifically, the acquisition consolidated a runtime that had been quietly funded by Sun for fifteen years under a much more aggressive owner.

The early years were rocky. Java 7 had been Sun's planned 2008 release; it didn't ship until July 2011, eighteen months after Oracle closed. James Gosling left Oracle in April 2010, two and a half months after the close. The high-profile Oracle v. Google Java API copyright suit was filed August 12, 2010 (see below). Several members of the original Sun Java team left for Google, Twitter, and elsewhere. The community read the early period as Oracle squeezing every monetization angle — rebrandings, support-contract pushes, the 2018 commercial-license pivot.

From Java 9 (2017) onward the picture stabilized. Mark Reinhold's six-month cadence, the open development of OpenJDK on GitHub, the 2021 NFTC license that returned a free Oracle JDK for production use, the funding of Project Loom and Panama, and the multi-vendor OpenJDK ecosystem (Adoptium, Corretto, Microsoft, Red Hat) collectively produced the most active period of Java language and platform evolution since the J2SE 1.2 / 5 era.

Oracle v. Google — the Java API lawsuit (2010–2021)

Oracle America, Inc. v. Google LLC was filed on August 12, 2010, eight months after Oracle's acquisition of Sun closed. Oracle alleged that Android — which had reimplemented 37 Java SE API packages without a license — infringed Oracle's copyrights and patents in the Java APIs. The patent claims faded early; the copyright fight became one of the longest-running and most consequential intellectual-property cases in software history.

Eleven years, two trials, two Federal Circuit appeals, and a global pandemic later, the U.S. Supreme Court ruled 6–2 on April 5, 2021 that Google's reimplementation of the API declarations qualified as fair use. The Court's opinion deliberately sidestepped whether APIs are copyrightable in the first place — a question the industry had been desperate to settle — and ruled narrowly on the fair-use question.

The ruling validated a generation of clean-room API reimplementations (Wine, ReactOS, the entire Linux ABI compatibility story) and removed an existential cloud over open-source software. For Java specifically, it closed an eleven-year overhang on the entire platform's first decade. The Java-to-Kotlin shift on the Android side — Google announced first-class Kotlin support at I/O 2017, and shipped that support in Android Studio 3.0 — started years before the ruling. Cross-link to the Android version page’s Oracle v. Google section for the parallel platform-side narrative.

OpenJDK — the open-source pivot

Sun promised at JavaOne in May 2006 that Java would become open source and delivered the first installment on November 13, 2006, releasing the HotSpot VM and the javac compiler under GPL v2. The class libraries followed on May 8, 2007, under GPL v2 with the Classpath Exception that makes the runtime safe to embed in proprietary applications. The reference implementation became OpenJDK; Sun's commercial JDK and OpenJDK were essentially the same code from Java 7 onward. The decision was driven partly by Linux distributions: Red Hat, Debian, and Ubuntu had been unable to ship Sun JDK for years because of its proprietary license, and the gap had given GNU Classpath (a clean-room reimplementation, started in 1998) momentum it shouldn't have needed.

The 2018 dust-up around "Oracle JDK is now paid" was a licensing change to the Oracle-branded JDK distribution, not to OpenJDK itself; OpenJDK has remained GPL+CE throughout. Oracle reversed the production-charging posture in 2021 with the No-Fee Terms and Conditions (NFTC) license, first applied to Java 17, returning the Oracle JDK to free for production use. The reversal is narrower than it first reads: Oracle keeps only the newest LTS on NFTC terms and moves each older LTS's update releases to the paid Java SE OTN license about a year after its successor ships. Java 17 updates made that move in October 2024; Java 21 updates follow with the October 2026 Critical Patch Update, and Oracle has dated Java 25's own move to after September 2028 — leaving Java 25 the free Oracle line until then. That rolling deadline is the reason most cloud and enterprise deployments standardize on a non-Oracle distribution — Adoptium Temurin, Amazon Corretto, Azul Zulu, Microsoft Build of OpenJDK — whose GPL+CE builds carry no equivalent cutoff.

The six-month cadence (September 2017–)

Java 9 shipped in September 2017, three years late from the original 2014 plan. The delay was driven by Project Jigsaw — the JDK module system — which was contentious enough in the community to delay the entire release while it was reworked. Mark Reinhold, the chief architect of the Java Platform Group, used the post-mortem to make a structural change: time-boxed releases every six months instead of feature-driven multi-year cycles, with one release every three years designated LTS for enterprise customers who couldn't or wouldn't upgrade twice a year. Oracle shortened that LTS interval to two years in 2021, which is why Java 11 to 17 is a three-year gap and every gap since is two.

The cadence shipped its first release with Java 10 in March 2018 and has held since. It has been the single most consequential structural change to Java since the platform launched. The benefits: features that are ready ship when they're ready, instead of waiting on a release-blocker; previews and incubators let the community try features at scale before they're set in stone; the JDK can deprecate and remove old code on a predictable schedule. The downsides: enterprise customers who pin to LTS are perpetually two to four years behind the cutting edge, and the "what JDK should I use?" question has become substantially more nuanced.

LTS releases under the cadence: Java 11 (September 2018), Java 17 (September 2021), Java 21 (September 2023), Java 25 (September 2025), and Java 29 (planned September 2027). Each LTS gets five years of Oracle Premier support, then paid Extended Support — three further years on the recent lines (Java 17 to September 2029, 21 to September 2031, 25 to September 2033), and considerably longer on the older lines, where Oracle has stretched Java 8's Extended window to December 2030 and Java 11's to January 2032. Vendor distributions typically extend free public updates further on each LTS — Corretto and Temurin have the longest published roadmaps.

GraalVM

GraalVM began as a research project at Oracle Labs around 2011. The 1.0 line never reached a final build — it ran as release candidates into April 2019 — and the first production-ready release shipped as GraalVM 19.0 on May 9, 2019, when the project moved to calendar-style version numbers. Two pieces matter: the Graal JIT compiler (an alternative HotSpot JIT written in Java) and native-image (an ahead-of-time compiler that produces standalone executables with sub-100ms cold-start times). The native-image story is the Java answer to Go and Rust on serverless and microservice deployment ergonomics — small binaries, fast startup, low memory footprint — while preserving the Java language and BCL developer experience. Spring Boot, Quarkus, Helidon, and Micronaut all support native-image as a first-class deployment path. Licensing splits by edition: GraalVM Community Edition ships under GPL v2 with the Classpath Exception, the same terms as Oracle's OpenJDK builds, while Oracle GraalVM ships under the GraalVM Free Terms and Conditions (GFTC), introduced in 2023 with the GraalVM for JDK 17 and 21 builds — free for commercial and production use, but permitting redistribution only when it is not for a fee.

Project Loom — virtual threads

Project Loom, started by Ron Pressler at Oracle in 2017, set out to fix a structural problem in Java's concurrency model: thread-per-request code was easy to write but expensive to run, while async/reactive code was efficient but hard to read, debug, and instrument. Loom's answer was virtual threads — user-mode threads scheduled by the JVM on a small pool of OS carrier threads — that preserve the synchronous, thread-per-request programming model without the resource costs.

Virtual threads entered preview in Java 19 (September 2022) and graduated to stable in Java 21 LTS (September 2023). The release that Java engineers had been waiting on for a decade. The associated work — structured concurrency, scoped values — continued to mature through Java 22 to 26: scoped values reached stable in Java 25, while structured concurrency was still previewing in Java 26 (JEP 525, sixth preview). openjdk.org/projects/loom remains the project hub. Kotlin coroutines (stable in Kotlin 1.3, October 2018) and Swift’s async/await + actors (Swift 5.5, September 2021) are the two most influential contemporary takes on the same problem — the three languages converged on similar ergonomics from different starting points.

Project Panama — foreign function & memory

Project Panama, started in 2014, set out to replace JNI — the 1996-era C bridge that had stewed in its own complexity for two decades — with a modern, safe, performant native interop story. The deliverables are the Foreign Function & Memory API (call native code, manage off-heap memory) and the Vector API (SIMD intrinsics from Java code). The Foreign Function & Memory API graduated in Java 22 (March 2024); the Vector API has remained in incubator longer than any feature in Java history while the Valhalla value-type story catches up. openjdk.org/projects/panama.

Project Valhalla — value types

Project Valhalla, started by Brian Goetz around 2014, is the long-running effort to add value types (immutable, identity-less, flat-laid-out structs) to Java. The goal is the same as records but at the runtime level: avoid the boxed-object overhead for things that should be plain data. The project's complexity is largely about generics — making List<Point> store flat Point values rather than boxed Point references requires extending the type system in compatible ways. Twelve years in, the first shippable increment finally has a release attached: JEP 401, Value Objects, was targeted at JDK 28 on July 30, 2026 and is integrated in the main line, arriving as a preview language and VM feature when JDK 28 ships in March 2027; the companion JEP 539 (strict field initialization in the JVM) previews alongside it. A value class gives up object identity, so == compares field values and the JVM is free to lay instances out flat inside fields and arrays instead of chasing references. Earlier pieces of the project shipped as ordinary features along the way — records, sealed classes, and the identity-vs-value groundwork. openjdk.org/projects/valhalla.

Java EE → Jakarta EE

Java's enterprise edition — Java 2 Enterprise Edition (J2EE) in 1999, Java EE from 2006 — was always a distinct product from Java SE: a set of additional specifications (Servlet, JSP, EJB, JMS, JPA, CDI, JAX-RS, etc.) implemented by application servers like JBoss, WebSphere, WebLogic, GlassFish, and Payara. In September 2017, Oracle announced it would hand Java EE off to the Eclipse Foundation. The renamed project became Jakarta EE in 2018 (Oracle retained the "Java" trademark for the SE side). The javax.* package namespace was renamed to jakarta.* in Jakarta EE 9 (December 2020) — a once-in-a-platform breaking change that took most of the ecosystem several years to absorb. Jakarta EE 11 landed in stages — Core Profile in December 2024, Web Profile in March 2025, and the full Platform in June 2025, aligned to Java 21 — and introduced the Jakarta Data specification; Jakarta EE 12 is in progress. The jakarta.ee roadmap continues independent of Java SE's release cadence.

People who actually shaped Java

Sun era: James Gosling (Oak / Java's primary designer; left Oracle April 2010), Patrick Naughton and Mike Sheridan (co-founders of the Green Project), Bill Joy (Sun co-founder; long-time advocate inside Sun for a portable runtime), Guy Steele (JLS co-author, language design), Arthur van Hoff (HotJava browser, applets era), Joshua Bloch (Collections framework, Effective Java, BigInteger; later left Sun for Google), Doug Lea (java.util.concurrent; SUNY Oswego professor; wrote the concurrency library Sun adopted into the JDK in Java 5).

Modern OpenJDK team: Mark Reinhold (chief architect of the Java Platform Group; Mr. JEP), Brian Goetz (Java Language Architect; Java Concurrency in Practice; lead of Project Valhalla), Ron Pressler (Project Loom lead), John Rose (Project Panama lead; invokedynamic and the JVM's dynamic-language plumbing), Maurizio Cimadamore (architect of the Foreign Function & Memory API), Aleksey Shipilëv (long-time JVM and GC engineer; Shenandoah lineage; now widely-cited industry benchmarker), Stuart Marks (collections, JEP author).

Distribution / community: Stephen Colebourne (Joda-Time, java.time / JSR-310), Martijn Verburg (London Java Community, Adoptium founding contributor), Tim Ellison (IBM J9 / Eclipse OpenJ9 lineage), Gil Tene (Azul co-founder; advocate for low-pause GC), Andrew Haley (Red Hat OpenJDK lead). Public face: Venkat Subramaniam, Trisha Gee, Nicolai Parlog, Mala Gupta, and the JavaOne / Devoxx speaker rotation.

Find your version — in the terminal

The browser cannot detect what version of Java is installed on your machine. Run one of these in your terminal to see your real install.

What's installed?

Print the active runtime, the active compiler, and the binary's full path. The -version output goes to stderr; redirect with 2>&1 if you're piping it.

$ java -version                      # active JRE / JDK runtime
$ javac -version                     # compiler version (may differ from runtime)
$ which java                            # the binary on PATH
$ java -XshowSettings:properties     # java.home, java.vendor, java.runtime.name, etc.
$ java --list-modules               # every module in the JDK (Java 9+)

Install and switch between JDKs — SDKMAN!

SDKMAN! is the de-facto JDK version manager on Linux and macOS. Free, scriptable, supports every distribution. 

$ curl -s https://get.sdkman.io | bash      # one-time install
$ sdk list java                              # every available JDK across vendors
$ sdk install java 21.0.12+1.1-tem           # Temurin 21 LTS
$ sdk install java 25.0.4-tem                # Temurin 25 LTS
$ sdk install java 25.0.4-amzn               # Amazon Corretto 25
$ sdk use java 21.0.12+1.1-tem               # this shell only
$ sdk default java 25.0.4-tem                # persistent default

OS-native installers

If you'd rather not run SDKMAN!, every major OS has native package commands.

# macOS — Homebrew. Tap available for every distribution.
$ brew install --cask temurin
$ brew install --cask corretto
$ brew install --cask zulu

# Windows — winget. Microsoft, Eclipse, Oracle, Amazon, Azul all publish IDs.
> winget install EclipseAdoptium.Temurin.21.JDK
> winget install Microsoft.OpenJDK.21
> winget install Amazon.Corretto.21.JDK

# Debian / Ubuntu — Adoptium APT repo
$ sudo apt install temurin-25-jdk

# Red Hat / Fedora / Amazon Linux
$ sudo dnf install java-25-amazon-corretto-devel

Pin a project to a specific JDK

SDKMAN! and most build tools read a per-project pin so the right JDK is selected automatically.

# SDKMAN! — commit a .sdkmanrc, set sdkman_auto_env=true
$ sdk env init                       # writes .sdkmanrc

# Maven — pom.xml <maven.compiler.release>
<properties>
  <maven.compiler.release>25</maven.compiler.release>
</properties>

# Gradle — build.gradle.kts toolchain
java {
  toolchain {
    languageVersion = JavaLanguageVersion.of(25)
  }
}

Sources: openjdk.org/projects/jdk; JEP archive; Oracle Java SE Support Roadmap; Adoptium Temurin support roadmap; Amazon Corretto support calendar; Red Hat OpenJDK life cycle; endoflife.date/java; the Supreme Court opinion in Google v. Oracle; and the books and JEPs cited inline. Last updated September 2026.

Mungomash LLC · More data pages