what's next

the picture

you know how java used to change every few years in one big lump, and now there's a release every march and september? the six-month train means there's always a next release with a list of what's on board, and a pipeline of proposals behind it. reading that pipeline is a skill: knowing the difference between "targeted", "proposed" and "draft" tells you what you can plan around and what you can only watch.

think of a train timetable plus a list of passengers with tickets. a JEP that's targeted has a ticket for a specific train. proposed to target is at the counter buying one. a candidate is in the station with no ticket yet. a draft is still deciding whether to travel.

how a feature gets on the train

a few things trip people up: a JEP can be withdrawn at any point (string templates were, see amber), targeted isn't the same as shipped, and a feature that previews four times has four JEPs, each one delivered. when a blog says "java 28 will have X", check which state X's JEP is actually in.

jdk 28, as of october 2026

here's the jdk 28 list from its project page (last updated october 7), plus the main things behind it:

the JDK hasn't posted jdk 28's rampdown schedule yet, but the cadence puts general availability in march 2027 (jdk 26 shipped on march 17, 2026, and jdk 27 on september 15). jdk 29, in september 2027, is planned to be the next LTS release, two years after 25 (more in the release timeline).

a JSON API in the JDK

the one that'll touch the most everyday code: java has never had a JSON parser in the JDK, so every project pulls in a library. JEP 540 adds a small one, as an incubator in jdk 28. it isn't trying to replace the big libraries (no data binding to your classes); it's for reading and writing JSON without a dependency:

// jdk 28, --add-modules jdk.incubator.json (JEP 540, incubator). illustrative only.
import jdk.incubator.json.*;
 
JsonValue json = Json.parse("""
    { "service" : "web_server", "id" : 3, "tags" : ["blue", "edge"] }
    """);
String service = json.get("service").asString();           // "web_server"
int id = json.get("id").asInt();                           // 3
String first = json.get("tags").get(0).asString();         // "blue"
json.tryGet("owner").ifPresent(o -> IO.println(o));        // a member that might not be there

JsonValue is a sealed interface (JsonObject, JsonArray, JsonString, JsonNumber, JsonBoolean, JsonNull), so you can also switch over it with patterns. a missing member or a wrong type throws JsonValueException with a message that says what was expected.

JsonValue json = Json.parse("""
  {
    "service" : "web_server",
    "id" : 3
  }
  """);
IO.println(json.toString());

final will mean final

final fields can still be changed today, by deep reflection (Field.setAccessible(true) then set). serialization libraries and some frameworks rely on that, and it means the JVM can't fully trust final, which limits optimizations like treating a final field as a constant. JEP 500 (java 26) starts closing that door: such writes now print a warning, and a future release will make them fail unless you opt in with --enable-final-field-mutation. you can test your code against the future today on 26 or later:

# jdk 26+: make illegal final field writes throw now, instead of in some future release
java --illegal-final-field-mutation=deny -jar app.jar

it's the same pattern as JEP 472 for native access: warn for a while, then require opt-in. if your app passes with deny, it's ready.

CRaC: snapshot a warm JVM

Coordinated Restore at Checkpoint takes a different route to fast startup than Leyden. instead of caching what a training run learned, it freezes the whole running process (heap, JIT-compiled code, threads) to disk once it's warm, and later restores it in milliseconds, already at peak speed.

the catch is the status. CRaC is an OpenJDK research project, not part of mainline OpenJDK, and there's no JEP. you get it from vendors that ship CRaC builds (Azul and BellSoft do), real checkpoints need linux (on macOS and windows, Azul's builds only simulate them, for testing your callbacks), and an image contains everything that was in memory, secrets included. Leyden ships in every JDK and gives up very little; CRaC restores faster but asks more of your app and your platform.

how to follow along

this chapter is a snapshot of october 2026. here's how to check it yourself, which is what was done for every status on this page:

• openjdk.org/jeps/0 is the index of every JEP, with its current state. each JEP page has a status and, once targeted, a release.
• openjdk.org/projects/jdk/28 (and so on) lists exactly what's targeted to that release, and the schedule once it's posted.
• project pages (valhalla, leyden, amber, loom, panama, babylon under openjdk.org/projects) list each project's JEPs, design notes and early-access builds.
• jdk.java.net/28 has early-access builds: download one and try the previews yourself, months before release.
• the jdk-dev mailing list is where new candidates and "proposed to target" announcements go, each with a review deadline.
• inside.java, run by Oracle's java team, collects the newscasts, articles and talks that explain what's coming.