skip to content

What is Java's time-based release model, how do its version numbers read, and who declares a release LTS?

level: middleimportance: should knowfreq 52%

answer

  1. the date is fixed, the content varies
  2. March and September
  3. feature, interim, update, patch
  4. a support promise, not a release stage
  5. optional part of the version string

basics

~20 s

Java ships a feature release every six months, numbered feature.interim.update.patch so the number counts release cycles, not compatibility. LTS is a support promise that JDK vendors declare for chosen releases, not a stage of the release process.

solid answer

~40 s

Since JDK 10, a feature release ships every six months, in March and September, on a fixed date: the feature set freezes at Rampdown Phase One, and what misses it waits for a later release. Under JEP 322 the version number is `$FEATURE.$INTERIM.$UPDATE.$PATCH` and encodes the passage of time, not compatibility. `$INTERIM` stays 0, `$UPDATE` rises a month after GA and every three months after that, and trailing zeros are dropped, so `27` is followed by `27.0.1`. LTS is not part of that process. A JDK vendor decides to offer long-term support for a release, and its builds should then carry an `$OPT` starting `LTS`, as in `25.0.3+9-LTS`. Oracle's roadmap lists 8, 11, 17, 21 and 25, with 29 planned next; for other releases the norm is two updates, then maintenance stops.

code

java · 12 lines
java
public class VersionCheck {
    public static void main(String[] args) {
        Runtime.Version running = Runtime.version();
        System.out.println("feature " + running.feature() + ", update " + running.update());

        Runtime.Version lts = Runtime.Version.parse("11.0.2+13-LTS");
        System.out.println(lts.feature());  // 11
        System.out.println(lts.update());   // 2
        System.out.println(lts.build());    // Optional[13]
        System.out.println(lts.optional()); // Optional[LTS]
    }
}

go deeper

for a junior

Recall the rhythm and the vocabulary: a feature release every six months, in March and September, and the releases commonly called LTS: 8, 11, 17, 21 and 25. Say that LTS is about how long support lasts.

for a middle

Explain what each element of the version number counts and when it changes, why the number stopped encoding compatibility, and where the LTS marker comes from: a vendor's build, shown in the optional part of the version string.

for a senior

Show how the model drives an upgrade policy: apply every quarterly update, know when your release's updates stop, and budget for the incompatible changes that accumulate when you jump several feature releases at once.

for a principal

Weigh standardising on LTS against following each feature release: low churn and vendor support dates on one side, earlier features and smaller upgrade steps on the other, plus which vendor's terms the organisation actually depends on.

## The train: the date is fixed, the content varies Java's **time-based release model** fixes when a release ships and lets what it contains vary. A **feature release** ships every six months, in March and September: JDK 10 reached General Availability (GA) in March 2018, JDK 11 followed that September, and JDK 27 arrived on 15 September 2026. The older model gated each major release on large new features, which made it prone to unpredictable delays; JEP 14 records that the JDK left it starting with JDK 10. JEP 3 defines the process. The main line stays open for new work, and every June and December it is forked into a stabilization repository for the next release, which then passes through three phases: 1. **Rampdown Phase One (RDP 1)**: the feature set is frozen, and no further JEPs can be targeted to the release. 2. **Rampdown Phase Two (RDP 2)**: only P1 and P2 bugs remain candidates. 3. **Release Candidate (RC)**: only P1 bugs remain candidates, and GA follows. For JDK 27 those phases began on 4 June, 16 July and 6 August 2026. A feature that is not ready **misses the train**: it waits for a later release, six months away at the earliest, and the date does not move. ## Reading the version number JEP 223 (JDK 9) dropped the leading `1` from version numbers, so names like `1.7.0_60` gave way to the `9` style, and it defined `$MAJOR.$MINOR.$SECURITY`. JEP 322 (JDK 10) then recast the elements, because a release's significance and compatibility are not known until its final feature integrates, so a number that encoded them could not be known in advance. Today's number counts **the passage of time, in release cycles**: | Element | What increments it | Under the six-month model | |---|---|---| | `$FEATURE` | Every feature release, regardless of content | Every six months | | `$INTERIM` | A non-feature release with compatible fixes and enhancements | Always 0, reserved for a future model | | `$UPDATE` | A compatible release fixing security issues, regressions and bugs in newer features | One month after `$FEATURE`, then every three months | | `$PATCH` | A compatible release fixing a small number of critical issues | When one is needed | Four rules finish the reading: - **No trailing zeros.** A feature release is `27`, not `27.0.0`, and its first update is `27.0.1`. - **Comparison is numeric and pointwise.** `10.0.4` is less than `10.1.2`, and `10.0.2` is less than `10.0.2.1`. - **Later elements belong downstream.** The fifth element onward is reserved for consumers of the JDK code base, for example an implementor's own patch releases. - **A version string wraps the number.** `11.0.2+13-LTS` is version number `11.0.2`, build `13`, optional information `LTS`. A feature release may add features, may remove one given notice at least one feature release ahead, and may make incompatible changes when justified, so the first number rising says that a cycle passed and nothing about how much changed. In code, `Runtime.version()` returns a `Runtime.Version` with `feature()`, `interim()`, `update()` and `patch()`; `major()`, `minor()` and `security()` have been deprecated since 10. The `java.version.date` system property gives a release's GA date. ## What LTS means and who declares it **LTS, long-term support,** means a vendor keeps backporting fixes to a release and shipping update releases for years, every January, April, July and October. Three layers answer who declares it: - **Not the release process.** JEP 3 never mentions LTS, and neither do the JLS or the JVMS; every feature release goes through the same phases. - **The implementor, for its own builds.** JEP 322 frames LTS as something an implementor offers, and says `$OPT` should then start with `LTS`, which makes `java --version` print `LTS`. A JDK 25 build carrying that marker prints `openjdk 25.0.3 2026-04-21 LTS`. - **In practice, a largely shared list.** JEP 14 says most JDK vendors have designated 8, 11, 17 and 21. Oracle's support roadmap lists 8, 11, 17, 21 and 25, intends a new LTS every two years (11 to 17 took three), and plans JDK 29 for September 2027, with that designation and date subject to change. Its dates apply only to its commercially supported builds, so check your own vendor's terms. For other releases, JEP 14 gives the norm as two update releases, after which maintenance ends because a new feature release exists. Oracle's roadmap puts JDK 27 in that group. ## What it means for choosing a version | Policy | You get | You pay | |---|---|---| | Stay on an LTS | Low churn, years of update releases | New language and API features only when you move to a later release | | Follow each feature release | Newest features, smaller upgrade steps | A release move every six months, because updates stop once the next release exists | Whichever you pick: - **Apply update releases.** They carry the security fixes. - **Do not read non-LTS as beta.** JDK 27 shipped production-ready, through the same process. - **Do not expect LTS to shrink an upgrade.** Moving from 21 to 25 crosses every incompatible change made in 22, 23, 24 and 25. - **Base long-lived library lines on LTS.** JEP 14 calls that wise, and advises against forking a maintenance line from a non-LTS baseline.

  • Why did JEP 322 stop encoding compatibility and significance in Java's version number?
    In a time-based model those qualities are not known until a release's final feature integrates, so the number itself would not be known in advance. People would speak of ship dates and then switch to numbers, and tool authors would change version-inspecting code late in every cycle. Counting release cycles makes each number known well ahead.
  • What can break in code that works out the Java version by parsing a string?
    Anything expecting the old `1.7.0_60` shape: since JDK 9 `java.version` starts with the major number, and `Runtime.Version.parse("1.7.0_60")` throws `IllegalArgumentException`. Parsing launcher output can break too, because since JDK 10 the first line ends with a date and possibly `LTS` rather than the version. On JDK 10 or later, call `Runtime.version().feature()`.
  • Should a team run a non-LTS release such as JDK 27 in production?
    It can: JDK 27 is a production-ready GA release built by the same process, so the issue is support, not quality. The norm is two update releases, then maintenance stops because a newer feature release exists, so the team must be ready to move every six months. If it cannot, an LTS from its chosen vendor fits better.

A commuter train leaves on the timetable whether or not every passenger has arrived, and whoever misses it takes a later one; the departure time says nothing about how full or important that train is.

  • LTS releases are declared by the Java specification or by the JEP process.
  • A non-LTS release is a beta and is not meant for production.
  • A higher first version number signals bigger changes, as in semantic versioning.
  • LTS releases receive new language features through their quarterly update releases.
  • An LTS release has always come exactly every two years.
  • JDK 27 is numbered 27.0.0, and its interim digit counts its minor releases.

Six-month feature release cadence
Java 10
Time-based version numbers (JEP 322)
Java 10
Runtime.Version feature() and update() accessors
Java 10
JEP 223 version strings and Runtime.Version
Java 9

Assumes JDK 27 and Oracle's support roadmap updated 20 October 2026; future LTS designations and dates are subject to change.

context