Java in 2025: LTS Release, AI on JVM, Framework Modernization


Transcript:

2025 was not a quiet year for Java. The Java platform and the ecosystem around it continued to evolve rapidly, so let’s look at the major updates of the year.

Java turned 30 this year, which in tech terms usually means becoming a legacy fossil. But that did not happen. Java keeps adapting, modernizing, and still runs a large portion of the world’s critical infrastructure.

Java 25 is the new long-term support release. It brings numerous updates and 18 JEPs with new, improved, or revised functionality. LTS releases are the ones teams adopt and run in production for years, so this is a release worth checking out if you haven’t already. Among the important features are continuous improvements to Java Flight Recorder with better visibility and lower overhead, scoped values that move Java toward safer and more reliable concurrency with fewer thread-local risks, and the ahead-of-time cache from Project Leyden that improves startup and warm-up times. This is especially important for cloud-native and serverless environments. Compact object headers also reduce the memory footprint of Java applications. If you want a deep dive into every single JEP, check out my dedicated video on Java 25 features.

AI on the JVM kept gaining momentum in 2025. This year it crossed the line from an interesting experiment to something actually usable in production. The first production-ready version of Spring AI reached general availability in 2025. It provides a familiar programming model for integrating LLMs, vector stores, and AI workflows into Spring applications. LangChain4j was also very active this year and reached its first general availability release, bringing structured AI workflows to Java with a focus on strong type safety and JVM-friendly abstractions. Embeddable is a new project from Rod Johnson, the founder of Spring, aimed at building advanced AI agents on the JVM. It demonstrates that serious AI orchestration on the JVM is absolutely possible.

Kotlin 2.2 continued refining the language, tooling, and compiler performance. It also improved multiplatform support across web, server, and mobile. Kotlin’s popularity keeps growing, and it now stands shoulder-to-shoulder with Java in backend development. Kotlin also owns the multiplatform story across platforms. According to general feedback, KotlinConf 2025 felt very backend-focused, with a lot of attention on performance tooling and real-world use cases.

The Spring Framework team was also very busy this year. There were numerous releases across the Spring ecosystem, with Spring Boot 4 and Spring Framework 7 standing out. These releases modernized the ecosystem with cleaner APIs, better performance, and closer alignment with newer Java versions.

Quarkus released a new LTS version, 3.27, reinforcing its position as a serious choice for cloud-native Java applications with fast startup times, low memory usage, and aggressive optimizations. Apache Flink 2 marked a major shift in real-time data processing, introducing new asynchronous models and improved APIs that make streaming systems more powerful and expressive.

Vaadin merged Hilla into Flow, simplifying its ecosystem and reducing fragmentation. Vaadin 25 focused on being slimmer, faster, and more modern. The Micronaut framework continued refining its ecosystem around HTTP, messaging, security, and observability, with better OpenTelemetry integration and support for modern Java and Kotlin versions. Ktor kept gaining traction as a lightweight, Kotlin-first framework, continuing to improve its HTTP engine, coroutine-based concurrency model, and plugin system.

IntelliJ IDEA added support for Java 25 and Spring Framework 7, keeping pace with the ecosystem and making upgrades easier. JetBrains also introduced a new unified IntelliJ release strategy, simplifying versioning and making it easier to stay up to date. The Spring Debugger saw significant improvements in 2025, providing better insights into Spring applications at runtime without additional libraries or agents. JetBrains Research introduced LitmusKT, a testing tool for Kotlin multiplatform concurrency that helps uncover subtle concurrency issues that are otherwise very hard to reproduce.

Gradle 9 landed with a strong focus on performance and reliability. Builds are faster, more predictable, and better suited for large, complex projects. The configuration cache is now the preferred path in Gradle, delivering major speedups that are especially important for CI pipelines. OpenTelemetry continued evolving its stabilization and release practices, increasing confidence that today’s instrumentation will not break tomorrow.

BellSoft introduced hardened container images that are a strong fit for enterprise Java applications. These minimized images are based on Liberica JDK and Alpaquita Linux. They provide an immutable component set, up to 95% fewer vulnerabilities, and a single SLA from one vendor that covers the OS, runtime, and vulnerability management.

These were the major updates in and around the Java ecosystem in 2025. Of course, this is only the tip of the iceberg. There were many more releases across tooling, frameworks, and platforms. It was a busy year for Java, and we are looking forward to another year full of progress and innovation. If you enjoyed this video, don’t forget to like it, subscribe to the channel, and until next time.

Summary

2025 was a highly active year for Java, marked by the release of Java 25 as a new LTS and significant progress across performance, concurrency, and cloud-native capabilities. AI on the JVM matured from experimentation to production-ready solutions with Spring AI, LangChain4j, and new JVM-focused AI orchestration projects. Kotlin continued to strengthen its position alongside Java, while major frameworks like Spring, Quarkus, Micronaut, and Vaadin delivered substantial updates. Tooling and infrastructure also evolved, with improvements in IDEs, build systems, observability, and container security. Overall, the Java ecosystem remains modern, relevant, and well-positioned for the future.

About Catherine

Java developer passionate about Spring Boot. Writer. Developer Advocate at BellSoft

Social Media

Videos
card image
Apr 2, 2026
Java Memory Options You Need in Production

JVM memory tuning can be tricky. Teams increase -Xmx and assume the problem is solved. Then the app still hits OOM. Because maximum heap size is not the only thing that affects memory footprint. The JVM uses RAM for much more than heap: metaspace, thread stacks, JIT/code cache, direct buffers, and native allocations. That’s why your process can run out of memory while heap still looks “fine”. In this video, we break down how JVM memory actually works and how to control it with a minimal, production-safe set of flags. We cover heap sizing (-Xms, -Xmx), dynamic resizing, direct memory (-XX:MaxDirectMemorySize), and total RAM limits (-XX:MaxRAMPercentage) — especially in containerized environments like Docker and Kubernetes. We also explain GC choices such as G1, ZGC, and Shenandoah, when defaults are enough, and why GC logging (-Xlog:gc*) is mandatory before tuning. Finally, we show how to diagnose failures with heap dumps and OOM hooks. This is not about adding more flags. It’s about understanding what actually consumes memory — and making decisions you can justify in production.

Videos
card image
Mar 26, 2026
Java Developer Roadmap 2026: From Basics to Production

Most Java roadmaps teach tools. This one teaches order — the only thing that actually gets you to production. You don’t need to learn everything. You need to learn the right things, in the right sequence. In this video, we break down a practical Java developer roadmap for 2026 — from syntax and OOP to Spring, databases, testing, and deployment. Structured into 8 levels, it shows how real engineers grow from fundamentals to production-ready systems. We cover what to learn and what to ignore: core Java, collections, streams, build tools, Git, SQL and JDBC before Hibernate, the Spring ecosystem, testing with JUnit, and deployment with Docker and CI/CD. You’ll also understand why most developers get stuck — jumping into frameworks too early, skipping SQL, or treating tools as knowledge. This roadmap gives you a clear path into real-world Java development — with priorities, trade-offs, and production context.

Further watching

Videos
card image
Apr 30, 2026
Java Flight Recorder Tutorial: How to Profile Java Applications

High CPU, GC spikes, or slow startup are common production issues, but logs and metrics don’t always reveal what the JVM is actually doing. Java Flight Recorder (JFR) provides a precise, low-overhead view of JVM behavior, safe for use even in production environments. In this video, you’ll learn how to use JFR to identify real bottlenecks such as CPU hotspots, memory allocation pressure, thread contention, and I/O stalls. We walk through the full workflow, including starting recordings with JVM flags, controlling them via jcmd, running JFR inside Docker containers, and attaching to live systems using ephemeral containers. Then we analyze a real Spring Boot recording in JDK Mission Control, breaking down GC behavior, allocation patterns, thread states, and method-level hotspots. If you want to move from symptoms to root cause with more confidence, this approach will help. Full article with commands and examples: [https://bell-sw.com/blog/how-to-profile-java-applications-with-jfr-beginner-s-guide/](https://bell-sw.com/blog/how-to-profile-java-applications-with-jfr-beginner-s-guide/)

Videos
card image
Apr 22, 2026
Dynamic SQL Queries with Spring Data JPA in 6 Minutes

If your repository layer has multiple queries for different filter combinations, your data access logic is already getting harder to maintain. In this video, we implement dynamic SQL queries in Spring Data JPA using Specifications — a composable approach that helps avoid query duplication and keeps your filtering logic clean. We build a flexible filtering system with optional parameters (category, language, format, price) and show how Specification.unrestricted() skips empty filters, while Specification.allOf(...) combines them into a single query. We also address a common issue: string-based field access. It’s fragile and can break at runtime when your model changes. Using the JPA Static Metamodel, we move to compile-time safety. The result is a cleaner, more maintainable way to implement dynamic filtering in Spring-based applications.

Videos
card image
Apr 8, 2026
Best Oracle Java Alternatives in 2026 Comparison of OpenJDK Distributions

A comparison of major OpenJDK distributions (Temurin, Liberica, Zulu, Corretto, Semeru, etc.), covering who maintains them, how updates are delivered, and what lifecycle guarantees they provide. We also explain why upstream OpenJDK isn’t production-ready and how your vendor choice impacts real-world systems. Useful for Spring Boot, containers, and Kubernetes to avoid hidden risks and choose the right runtime.