Guna SantoshDeep Srivastava

Posted on Aug 10

Java Evolution: LTS vs Non-LTS, and What's Actually Current Right Now

#java #lts #coding #version

Ask five Java developers "should we upgrade to the new version?" and you'll usually get five different answers, because most people are quietly confused about the difference between an LTS release and a regular one. So here's Java's version history laid out clearly, plus the actual reasoning behind why some versions matter a lot more than others.

One quick note before we start: version timelines move fast, and even a well-made reference chart can go stale within months. I checked the current status of every version below, so this reflects where things actually stand today.

How Java got here: a quick timeline

1991 — James Gosling starts the project at Sun Microsystems (originally named Oak)
1996 — Java 1.0, the first official release
1997 — Java 1.2 (J2SE) adds the Collections Framework and Swing
2004 — Java 5 adds generics, annotations, and enums
2014 — Java 8 adds lambda expressions and the Streams API — arguably the biggest shift in how Java code is written
2018 — Java 11 becomes an LTS release
2021 — Java 17 (LTS) adds sealed classes and records
2023 — Java 21 (LTS) adds virtual threads
2025 — Java 25 (LTS) is the current long-term support version
2026 — Java 26 has already been released (more on this below)

LTS vs. Non-LTS: the difference that actually matters

Since Java 9, Oracle ships a new version every six months. But not all versions are treated the same:

LTS (Long-Term Support) — a version that gets security updates and bug fixes for years, usually 8 or more. These are the versions companies actually run in production.
Non-LTS (feature release) — a version that only gets 6 months of support before the next one replaces it. Great for trying out new features early, risky to run in production long-term since support runs out fast.

Think of it like phone operating systems: LTS releases are like a "stable" update you can trust for years, while non-LTS releases are more like a beta you use to see what's coming next.

Current LTS versions

Version	Released	Support commitment
Java 8	2014	Extended support into the early 2030s
Java 11	2018	Extended support winding down
Java 17	2021	Supported into 2029+
Java 21	2023	Supported into 2031+
Java 25	2025	Supported into the early 2030s (current LTS)

Exact support end dates shift as Oracle updates its policies, and they also differ depending on whether you're using Oracle's JDK or a free OpenJDK build from another vendor. For the real, current numbers, check Oracle's official Java SE Support Roadmap rather than trusting any single blog post or chart — this page gets updated as things change, most reference articles don't.

What's actually new in the versions people use today

Java 8 (2014) — the release most existing codebases were built on:

Lambda expressions and the Streams API
Optional, to reduce null-pointer bugs
A new Date & Time API

Java 11 (2018, LTS):

A proper HTTP client built in (java.net.http)
Local-variable type inference with var
Removed the old Java EE modules

Java 17 (2021, LTS):

Sealed classes, which let you control exactly which classes can extend a given class
Records, a compact way to write simple data-holder classes
Pattern matching improvements

Java 21 (2023, LTS):

Virtual threads (Project Loom) — lightweight threads that make handling thousands of concurrent tasks far cheaper
Record patterns and pattern matching for switch, both finalized
Sequenced Collections, giving collections a defined "first" and "last" element

Java 25 (2025, LTS, the current one):

Compact Object Headers, which shrink the memory every object uses
Flexible Constructor Bodies, finalized
Scoped Values, finalized

Correcting the record: Java 26 already shipped

If you've seen a chart listing "Java 26 (Upcoming)," that's now out of date — Java 26 was released on March 17, 2026. It's a non-LTS release, meaning 6 months of support before Java 27 takes over.

Java 26 finalized structured concurrency and flexible constructor bodies, and improved the Foreign Function & Memory API. Java 27 is scheduled for September 2026 — essentially right now, if you're reading this close to publish date. You can track exact release notes on OpenJDK's official JDK 26 project page.

LTS vs. Non-LTS, side by side

	LTS	Non-LTS
Support length	8+ years	6 months
Used for	Production systems	Trying new features early
Update frequency	Occasional patches	Replaced every 6 months
Examples	8, 11, 17, 21, 25	9, 10, 12, 13, 22, 23, 24, 26

How to check your Java version

java -version
javac -version

A real example of what that output looks like:

java version "25.0.1" 2025-10-21 LTS
Java(TM) SE Runtime Environment (build 25.0.1+9-LTS-27)
Java HotSpot(TM) 64-Bit Server VM (build 25.0.1+9-LTS-27, mixed mode, sharing)

That LTS tag in the version string is your quickest way to confirm whether you're on a long-term support version or a short-lived feature release.

Going deeper: why this is actually a licensing decision, not just a technical one

This is the part that trips up teams who've only ever worked with the free, open-source side of Java.

Oracle's official JDK builds come with a support lifecycle split into phases — Premier Support (full updates and patches) and Extended Support (patches available, usually at extra cost, for organizations not ready to upgrade). Once a version exits both phases, it moves to Sustaining Support, meaning no new security patches at all from Oracle — a real risk for anything handling sensitive data or subject to compliance requirements.

This is exactly why large companies plan Java upgrades years in advance instead of just "whenever." Falling behind on LTS versions isn't just a missed-features problem — once a version's support window closes, you're running unpatched software, which auditors and security teams take seriously.

If licensing cost is a concern, this is also why many companies run free OpenJDK builds (from vendors like Eclipse Adoptium, Amazon Corretto, or Azul) instead of Oracle's own JDK — same underlying code, different support and cost model. Worth knowing this distinction exists before assuming "Java" always means "Oracle's Java."

Quick answers, if this comes up in an interview

"What's the difference between LTS and non-LTS Java releases?" → "LTS versions get years of security updates and are meant for production. Non-LTS versions only get 6 months of support before the next release replaces them."
"Which Java version should a new project use?" → "The current LTS version, unless there's a specific new feature only available in a newer non-LTS release that's worth the shorter support window."
"How do you check what Java version you're running?" → "java -version from the terminal — the output also shows whether it's tagged LTS."
"Is Oracle's JDK the only option?" → "No — OpenJDK builds like Eclipse Adoptium or Amazon Corretto use the same underlying code and are free, with different support terms than Oracle's commercial JDK."

The short version

Java ships a new version every 6 months, but only some of those — the LTS releases — are meant to be run in production for years. Everything else is a short-lived preview of what's coming next. As of right now, Java 25 is the current LTS version, Java 26 has already been released as a short-term feature release, and Java 27 is due in September 2026. If you only remember one thing: check for the word "LTS" in your version string before deciding how long you can rely on it.

DEV Community