Java 26 Released: What Shipped in March 2026

Turker Senturk
Software
30 Mar, 2026
8 min read

March 2026 is the biggest month on the Java calendar. Java 26 shipped. JavaOne came back. The ecosystem delivered a stack of framework releases. Here’s everything that matters.

Java 26: What Dropped on March 17

Oracle released JDK 26 on March 17 — the same day JavaOne kicked off in Redwood City. It’s a non-LTS release (the previous LTS was JDK 25), containing exactly 10 JEPs and 2,825 total fixes across OpenJDK and JavaFX.

Five of the ten JEPs are still progressing through preview or incubator stages, which is normal for a mid-cycle release.

JEP	Feature	Status
JEP 500	Prepare to Make Final Mean Final	Final
JEP 504	Remove the Applet API	Final
JEP 516	Ahead-of-Time Object Caching with Any GC	Final
JEP 517	HTTP/3 for the HTTP Client API	Final
JEP 522	G1 GC: Improve Throughput by Reducing Synchronization	Final
JEP 524	PEM Encodings of Cryptographic Objects	2nd Preview
JEP 525	Structured Concurrency	6th Preview
JEP 526	Lazy Constants	2nd Preview
JEP 529	Vector API	11th Incubator
JEP 530	Primitive Types in Patterns, instanceof, and switch	4th Preview

What Are the Headline Features in Java 26?

JEP 516 is the release’s most significant landing. Ahead-of-Time object caching now works with any garbage collector — including ZGC. Previously, the startup acceleration work coming out of Project Leyden was tied to specific GC configurations. Now it’s universal. Sub-100ms cold starts for pure-Java applications are no longer a distant aspiration.

JEP 517 is quietly important: HTTP/3 support lands in the standard HttpClient API. It’s been a long time coming, and it matters for any server-to-server communication path where latency is a concern.

// HTTP/3 is now supported in the standard Java HTTP Client (JEP 517)
var client = HttpClient.newBuilder()
    .version(HttpClient.Version.HTTP_3)
    .build();

var request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.example.com/data"))
    .GET()
    .build();

var response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

JEP 526 — Lazy Constants introduces immutable value holders with deferred initialization. Think of it as a first-class Supplier<T> that guarantees single initialization, but baked into the language model rather than bolted on.

// Lazy Constants (JEP 526 — Second Preview)
// Value is computed once, on first access, and never again
static final LazyVal<HeavyResource> resource = LazyVal.of(HeavyResource::initialize);

public void doWork() {
    // resource.get() triggers initialization only on the first call
    resource.get().process();
}

JEP 504 closes a chapter: the Applet API is gone. It was deprecated in Java 9 (2017). Nobody should be surprised — but somebody is always surprised.

JEP 500 — Prepare to Make Final Mean Final issues warnings about deep reflection mutating final fields. This is preparation work for a future where final is actually enforced as a security and correctness guarantee, not just a polite suggestion.

What’s Coming in Java 27?

JDK 27 early-access builds are already circulating (Build 15 landed this week). One JEP already targeted for 27 stands out:

JEP 527: Post-Quantum Hybrid Key Exchange for TLS 1.3 — hybrid classical/post-quantum key exchange is coming to the JDK’s TLS stack. With NIST post-quantum standards finalized, the Java platform is getting ahead of the migration curve. If your application handles sensitive long-term data, this is the JDK release to plan your upgrade path toward.

What Did the Ecosystem Ship in March?

Spring Ecosystem

Spring Boot 4.1.0-M4 — adds custom Micrometer Metrics support for gRPC, with ConditionalOnMissingBean on the observation interceptor. RabbitMQ/AMQP changes pushed to November.
Spring Modulith 2.1.0-M4 — JobRunr event externalization support, plus opt-out for persisting event publications.
Spring AI 2.0.0-M4 — Google Search configuration for Gemini 3 models, dynamic disabling of native structured output, and Anthropic Agent Skills support.

Spring AI gaining Agent Skills support isn’t a footnote — it’s the Java ecosystem’s answer to the agentic toolchain question. If your team is building AI-powered backend services, you no longer need to reach for Python. For the full story on where Spring Boot 4 and Spring Framework 7 are headed, see Spring Framework 7 and Spring Boot 4 Released.

GraalVM & Native Image

GraalVM Native Build Tools 1.0.0 GA shipped. The native image build tooling hits its first stable release, resolving a Gradle test failure on latest GraalVM JDKs caused by a removed feature. This is the tooling that makes mvn package -Pnative actually reliable in CI.

Jakarta EE & Application Servers

Project	Release	What Changed
EclipseLink 5.0.0	GA	Jakarta Persistence 3.2, JPQL improvements
GlassFish 8.0.1	Maintenance	Bug fixes, JNA library migration
GlassFish 9.0.0-M1	First Milestone	Jakarta EE 12 target: Security 5.0, Faces 5.0, CDI 5.0
Open Liberty 26.0.0.3	GA	New `getUsersByAttribute()`, updated Jandex
Quarkus 3.34.0	Point Release	`ObjectLoader` deprecated, new `getResourceNames()`
Payara Platform	March 2026	27 deprecated parameters removed, memory leaks fixed

Security: Patch Micronaut Now

Micronaut 4.10.10 patches two denial-of-service vulnerabilities in form body binding and error response handling. If you’re running Micronaut in production, this is a mandatory upgrade.

Is Java Ready for AI Workloads in 2026?

Three projects are reshaping what the JVM is actually for in 2026:

Project Babylon is enabling GPU acceleration and direct machine learning model execution on the JVM. The long-term goal is letting Java code participate in AI inference pipelines without a Python intermediary — same JVM, same memory model, no serialization boundary.

Project Leyden continues compressing startup times toward sub-100ms. Combined with JEP 516’s AoT object caching landing in Java 26, the “Java is slow to start” objection is running out of runway. Serverless and edge deployments are increasingly viable targets.

Chicory — a JVM-native WebAssembly runtime — lets the JVM execute .wasm binaries directly. The interoperability story keeps expanding.

Oracle also announced the Java Verified Portfolio (JVP): a curated, Oracle-supported set of frameworks and libraries, including commercial support for JavaFX and Helidon. An opinionated enterprise stack. Whether that’s reassurance or lock-in depends on your relationship with Oracle.

What Happened at JavaOne 2026?

JavaOne returned to Redwood City, March 17–19, co-timed with the Java 26 launch. Oracle’s decision to align the conference with the release date is deliberate — it turns a changelog into a live event, giving community members something to demo, debate, and ship against in real time.

The conference covered four main tracks: language and platform, cloud-native and microservices, AI and machine learning on the JVM, and developer productivity. Project Babylon and Project Leyden headlined the platform track, reflecting how central startup performance and GPU acceleration have become to Oracle’s messaging for enterprise Java. The AI track drew the biggest crowds — a signal of where developer interest is moving, even in a traditionally conservative enterprise ecosystem.

Keynote themes centered on the Java Verified Portfolio, Oracle’s new curated framework stack, and the post-quantum cryptography roadmap landing in JDK 27. Attendance was strong. The Java community never stopped running events — see the March 2nd Java roundup for Devnexus 2026 coverage — but having JavaOne back in Redwood City carries symbolic weight that regional conferences don’t.

Beyond JavaOne, JavaLand ran March 10–12 in Germany, and Devnexus ran March 4–6 in Atlanta. The community calendar is full again.

The Verdict

Java 26 isn’t a landmark release — that was Java 25 (LTS). It’s a solid execution sprint: startup performance advances, HTTP/3 lands, applets are finally buried, and five features continue maturing toward finalization.

The real story in March 2026 isn’t any single JEP. It’s the trajectory. Java is moving faster, shipping better tooling for AI workloads, and closing the startup-time gap that kept it out of serverless and edge conversations for years. JDK 27 is the one to watch — it’s LTS, and it’s carrying post-quantum cryptography across the finish line.