Mungomash LLC
Java Versions

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; every fourth cadence release (11, 17, 21, 25)
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. Continued AOT, scoped values stable, more pattern-matching wins.
  • Standard six-month interim release; six months of Oracle public updates through September 2026.
  • Continued ahead-of-time class-loading and linking work that started in Java 24 (JEP 483 lineage).
  • Project Loom continues to harden virtual-thread pinning fixes and JFR observability for blocked carriers.
  • Project Panama foreign function & memory API continues to refine downcall stub generation.
  • Pattern-matching tightenings around primitive type patterns and deconstructors as they progress through preview.
  • Confirm exact JEP set against the openjdk.org/projects/jdk/26 page at build time.
Version
Java 25
Cadence
LTS
Premier Sep 2030
Sep 16, 2025
Current LTS. Successor to Java 21. Compact source files, primitive type patterns, scoped values.
  • Long-Term Support release. Oracle Premier through September 2030; Extended Support through September 2033 for paying customers. Adoptium Temurin and Amazon Corretto typically extend public free updates several years past Oracle Premier on LTS lines.
  • 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.
  • Primitive type patterns continue maturing in pattern-matching expressions.
  • Stream gatherers, structured concurrency, and the Class-File API continue refining.
  • 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.
  • Compact source files and instance main methods continued in preview.
  • Generational Shenandoah reaches experimental.
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 and flexible constructor bodies continued in 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.
  • 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 entered preview; eventually became the default in Java 23.
  • Foreign function & memory API in third preview; final in Java 22.
  • Removed the deprecated 32-bit Windows port.
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; pattern matching for instanceof final; strong encapsulation by default; Applet API removed.
  • Long-Term Support release. Oracle Premier through September 2026; Extended through September 2029. Was the dominant production target across the industry from 2022 through 2024.
  • Sealed classes graduated — restrict which classes may extend a class or implement an interface, enabling exhaustive pattern matching.
  • Pattern matching for instanceof graduated — if (obj instanceof String s) with the binding in scope.
  • Strong encapsulation of JDK internals by default — --illegal-access command-line flag was removed; libraries depending on sun.* internals must use the --add-opens escape hatch explicitly.
  • Applet API removed for removal — the in-browser Java story ended officially.
  • 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 October 2027 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.
  • Removed: launch-from-applet, the JNLP plugin install shell.

The six-month cadence — September 2017. Above this line: the Cadence era — time-boxed releases every March and September, with every fourth release designated LTS. 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 November 2026 at minimum; Amazon Corretto 8 through April 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
Jul 2022
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.
  • 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 November 2018; Extended through 2027 for paying customers. 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, applets in Netscape Navigator 2.0 (released a month earlier 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. /data/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's free public window for Java 8 closed years ago.

Distribution Vendor License (free use) LTS free public updates Notes
Oracle JDK
oracle.com/java		 Oracle NFTC since Java 17 (free for production); GPL+CE for OpenJDK builds Premier 5 yr after each LTS; Extended is paid only 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; LTS continued support becomes a community-maintained project (e.g. Red Hat leads Java 17 OpenJDK community updates).
Eclipse Temurin
adoptium.net		 Eclipse Foundation (Adoptium) GPL v2 + Classpath Exception ~4–5 yr per LTS; 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 8 yr+ per LTS (Corretto 8 through 2030; Corretto 11 through 2027; Corretto 17 through 2029) 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 Zulu Community is GPL+CE; Zulu Enterprise is paid Community: 8 yr+ per LTS. Enterprise: per contract. Long-running independent JDK vendor (founded 2013). Zulu Community is free and TCK-certified; Zulu Prime adds the Falcon JIT and high-performance C4 GC for paying customers.
Microsoft Build of OpenJDK
learn.microsoft.com/java/openjdk		 Microsoft GPL v2 + Classpath Exception Tracks Eclipse Temurin; commits aligned with the Adoptium roadmap. Microsoft's own free OpenJDK build, started in 2021. Default in Azure Java workloads and many Microsoft developer tools.
Red Hat OpenJDK
developers.redhat.com/products/openjdk		 Red Hat (IBM) GPL v2 + Classpath Exception ~6 yr per LTS for paying RHEL subscribers; community-led on Java 17+ Red Hat now leads the upstream OpenJDK project for the Java 17 LTS, taking over from Oracle after the public-update window closed. 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 ~6 yr per LTS 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 / EE
graalvm.org		 Oracle Labs GPL v2 + Classpath Exception (CE); UPL since 2024 for the JDK builds Tracks Oracle JDK cadence; 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, redistribution restrictions apply; UPL = the Universal Permissive License GraalVM moved to in 2024.

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. Netscape Navigator 2.0 shipped a Java runtime in December 1995 — the moment Java became real to the industry. Java 1.0 went GA on January 23, 1996.

"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 — 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 open-sourced Java under GPL v2 in November 2006 at JavaOne, with a Classpath Exception added shortly after to make 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 that ships with Java 17 and later, returning the Oracle JDK to free for production use. The episode is the reason most cloud and enterprise deployments now standardize on a non-Oracle distribution — Adoptium Temurin, Amazon Corretto, Azul Zulu, Microsoft Build of OpenJDK — even though the Oracle JDK is once again free.

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 every fourth release designated LTS for enterprise customers who couldn't or wouldn't upgrade twice a year.

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 and eight years of Oracle Extended (paid). 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 and shipped 1.0 in May 2018. 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. GraalVM moved to the Universal Permissive License in 2024, returning it to fully permissive open source for redistribution.

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, 23, 24, and 25. openjdk.org/projects/loom remains the project hub.

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, Valhalla is still incubating; pieces have shipped (records, sealed classes, identity vs. value distinction work). 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 shipped in 2024; 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), Maurizio Cimadamore (Project Panama lead), 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.5-tem                # Temurin 21 LTS
$ sdk install java 25-tem                    # Temurin 25 LTS
$ sdk install java 25-amzn                   # Amazon Corretto 25
$ sdk use java 21.0.5-tem                    # this shell only
$ sdk default java 25-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 releases; Amazon Corretto; endoflife.date/java; the Supreme Court opinion in Google v. Oracle; and the books and JEPs cited inline. Last updated April 2026.

Mungomash LLC · More data pages