Your AI-generated monthly roundup of Java platform, framework, and community updates.
December 2025 wrapped up a milestone year for Java, consolidating the big advances of Java 25 and Spring 7 while setting the stage for 2026. This month saw JDK 26 reach its feature freeze, early planning for Java 27, and a flurry of maintenance releases across frameworks (Spring Boot 4.0.1, Quarkus 3.30.5, Micronaut 4.10.x, etc.) to shore up stability and security. Enterprise Java vendors delivered year-end updates (Payara, GlassFish, Open Liberty), and the community reflected on key trends (the rise of AI on the JVM, accelerating modernization efforts). Below is a summary of the key updates by category, followed by detailed highlights.
| Category | Key Updates (December 2025) |
|---|---|
| Java SE & JDK | JDK 26 entered Rampdown Phase One (feature set frozen at 10 JEPs, including Remove the Applet API, HTTP/3 support, and new previews for value objects and pattern matching) [infoq.com]. JDK 27’s Expert Group was formed (led by Oracle’s Iris Clark) to target a September 2026 release [infoq.com]. With Java 25 now mainstream, the final public updates for legacy Java 8 and 11 are due in January 2026 [manorrock.com], cementing Java 17+ as the standard baseline. |
| Enterprise Java | Work progressed on Jakarta EE 12 (though Milestone 2 was rescheduled to Jan 2026) aiming for a mid-2026 release [blogs.eclipse.org]. Broad adoption of Jakarta EE 11 continued – multiple app servers (Open Liberty, WildFly, Payara, GlassFish) are already certified on EE 11 [infoq.com]. Vendor updates this month included Payara Platform 7.2025.2 (Dec edition) adding experimental CRaC checkpoint/restore support [infoq.com], GlassFish 7.1.0 (Java 17–25 support and MicroProfile 4) [infoq.com], and Apache TomEE 10.1.3 (improved Java 21 compatibility). |
| Frameworks & Libraries | The new Spring 7 / Spring Boot 4 generation saw its first maintenance releases: Spring Boot 4.0.1 (with 88 fixes and improvements [spring.io]) and Spring Framework 7.0.2, ensuring a smooth upgrade path. The Spring Tools 5.0 IDE plugin suite debuted with support for Spring 7/Boot 4 and built-in AI assistant integration (GitHub Copilot, Cursor) in Eclipse and VS Code [infoq.com]. Ecosystem momentum continued elsewhere: Micronaut 4.10.6 arrived (with bug fixes and a plan to require JDK 25 in Micronaut 5) [infoq.com], Quarkus 3.30.5 and Infinispan 16.0.5 delivered minor patches (security, stability) [infoq.com], [infoq.com], and the Spock 2.4.0 testing framework finally reached GA (adding Groovy 5 support and new testing annotations) [infoq.com] after a long beta. |
| Developer Tools | IntelliJ IDEA 2025.3 was released with full support for Java 25 and Spring 7 features (e.g. recognizing new modular starters and APIs) [blog.jetbrains.com], helping developers adopt the latest platform. The Eclipse IDE 2025-12 update similarly added Jakarta EE 11 support and early Jakarta EE 12 compatibility prep [manorrock.com]. Build tools moved forward: Gradle 9.3 hit its second release candidate with improved test reports and error diagnostics [infoq.com], and Apache Maven 4.0 neared the finish line – with Release Candidate 5 out, the community is testing the modernized Maven while awaiting a final GA (no date announced yet) [baeldung.com]. |
| Community & Trends | Java’s community wrapped up 2025 by reflecting on major trends. InfoQ’s Java Trends Report 2025 highlighted the surge of AI on the JVM (new agent frameworks like Embabel and JetBrains’ Koog) [infoq.com], the importance of Java 25 as a new baseline (frameworks now require Java 17+ by default) [infoq.com], and industry’s push to modernize legacy apps (with tools like OpenRewrite automating code upgrades) [infoq.com], [infoq.com]. With Java conferences mostly on winter break, community knowledge-sharing continued via year-end blog posts and videos – e.g. Baeldung’s deep dives on Spring Boot 4 and Maven 4, and the Inside Java newscast episodes #100 and #101 covering Project Valhalla and upcoming JDK 26 features [blog.jetbrains.com]. The Java ecosystem closes the year energized and ready for 2026’s innovations. |
JDK 26 Feature Freeze: The OpenJDK team marked a major milestone in early December by declaring JDK 26 in Rampdown Phase One. Per the OpenJDK schedule, Chief Architect Mark Reinhold announced that JDK 26’s feature set is now frozen—the main line of development has been forked to a stabilization repository, and no further JEPs will be added. This locks in the planned enhancements for the March 2026 Java release. In total, 10 JDK Enhancement Proposals (JEPs) are slated for JDK 26 GA. Notable items on the list include: [infoq.com]
final keyword to prepare for value types and ensure true immutability in the platform. [infoq.com]With these and a few other smaller enhancements locked in, developers can begin testing early-access builds of JDK 26 (Build 28 was the latest by mid-December). The focus now shifts to bug fixes and polish in the run-up to the release candidate. Notably, this Rampdown implies that JDK 26 will not include some features that missed the cutoff – any JEPs not on the above list will be deferred to JDK 27 or beyond. One interesting change already slated for post-26 is a plan to emit warnings for deep reflection (using reflection to access non-public JDK internals) in JDK 26. This isn’t a user-facing feature but a signal to framework developers: Java is tightening encapsulation (a continuation of Project Jigsaw’s goals), and such illegal reflective access will likely be disallowed in the future. JDK 26 will warn developers who rely on these hacks, giving them time to adapt. [infoq.com] [manorrock.com]
JDK 27 Begins Planning: Even as JDK 26 stabilizes, work is starting on JDK 27, slated for September 2026 (which is expected to be the next LTS release if Oracle continues its two-year LTS cadence). In the first week of December, JSR 402 (Java SE 27) was formally approved, establishing the Expert Group for Java 27. The expert group includes notable Java leaders such as Simon Ritter (Azul Systems) and Stephan Herrmann (Eclipse), with Oracle’s Iris Clark serving as Specification Lead. This group will guide the high-level goals of Java 27. The JDK 27 repo is already up and running – the first early access builds (Build 0, Build 1, etc.) became available, essentially as a fork of the current JDK 26 codebase with initial issue resolutions. No new features are in JDK 27 yet (and none announced publicly in December), but the milestone of forming the expert group indicates that larger proposals can now be targeted there. The Java SE 27 timeline foresees a public review of the spec in mid-2026 and a GA release by September 2026. [infoq.com]
Java 25 Adoption & Updates: December saw Java 25 (the current LTS, released in September) solidify its role as the new standard in production. Many organizations spent the last quarter migrating to JDK 25, and ecosystem support is catching up. For instance, Red Hat’s RHEL 10.1 (released in early December) includes OpenJDK 25 by default (as noted last month), and numerous tools and frameworks (from Spring to JHipster) have now certified support for Java 25. Oracle did not issue any new Critical Patch Update (CPU) in December (the next quarterly CPU is due in January), so JDK 25.0.1 remains the latest public build with security fixes. That October CPU also applied to older LTS versions (JDK 21, 17, 11, 8), and importantly marked the final scheduled updates for Java 8 and Java 11. As a reminder, January 2026 will bring Java 8u372 and 11.0.20.2, which are the last public patches for those versions. After that, Java 8 and 11 enter extended support only. This is a historic transition for the Java community: two of the longest-lived Java versions are finally bowing out of free support, underscoring that it’s time to be on Java 17 or newer. Many enterprises are indeed well underway migrating off Java 8/11, often straight to 17 or 21. In short, Java 25 is emerging as the “new normal”, and the platform’s evolution continues unabated with JDK 26 and 27 on the horizon. [manorrock.com]
Jakarta EE & Enterprise Java: Over on the enterprise Java side, the Jakarta EE Platform project made forward progress in December, though with a slight schedule tweak. The community had planned to finalize Jakarta EE 12 Milestone 2 by early December, but in the Jakarta EE Platform call it was decided to push Milestone 2 to January 27, 2026. This modest delay is intended to give participants more time (and to set up a new artifact staging system) without jeopardizing the overall timeline. The target for Jakarta EE 12 remains mid-2026 (Q2, likely June/July) for the final release, after a total of four milestones. By all accounts, Jakarta EE 12 will focus on developer experience and emerging needs – for example, a new specification Jakarta Query (for a standardized criteria/query API) has been accepted for inclusion in EE 12, and there’s an exploratory Jakarta AI initiative in the works (a sign of incorporating AI capabilities into enterprise Java, as noted last month). In the meantime, Jakarta EE 11 (released mid-2025) is seeing broad industry adoption. Many Java application servers have certified on EE 11: IBM Open Liberty, Red Hat WildFly, Eclipse GlassFish, Payara, Apache TomEE and others achieved compatibility, moving Jakarta EE 11 into the “early majority” phase for enterprise users. This means Java EE shops are finally enjoying the updates from EE 10/11 (like the switch to jakarta.* namespace, new APIs for JSON, concurrency, etc.) on production-grade servers. [blogs.eclipse.org] [infoq.com]
December brought a round of product releases for Java EE implementations, keeping them aligned with the latest Java and Jakarta specs:
Eclipse GlassFish 7.1.0 – the reference implementation for Jakarta EE – was released, bringing full support for JDK 25 (the supported Java range is now 17 to 25, dropping support for Java 11) and introducing some Jakarta EE 11 features. GlassFish 7.1 also implements MicroProfile 4.0 and improves its admin CLI (now using JLine for a better console experience). These updates ensure GlassFish remains a viable testbed for the newest Jakarta APIs, even though in production other servers are more commonly used. [infoq.com]
IBM Open Liberty 23.0.0.12 (December 2025) – Liberty’s monthly update – included security and compliance enhancements. Notably it addressed a vulnerability (CVE-2025-7962) in Jakarta Mail’s handling of SMTP inputs, and added options for FIPS 140-3 compliant crypto when using IBM’s Semeru JDK (Java 17, 21, 25). Liberty continues to fine-tune performance and compatibility with Java 25 and virtual threads (it has been experimenting with these features in previews). Liberty’s December beta also enabled users to supply custom encryption keys for stored passwords, reflecting enterprise demand for controllable security. [infoq.com]
Payara Platform 7.2025.2 – Payara’s December 2025 release (Payara Community Edition 7, which is based on Jakarta EE 11) – arrived with various fixes and component upgrades across its editions. A headline feature is experimental support for CRaC (Coordinated Restore at Checkpoint) in both Payara Community 7.2025.2 and Payara Enterprise 6.33.0. CRaC is a cutting-edge OpenJDK project that allows taking a snapshot of a running Java process and restoring it almost instantly, effectively enabling lightning-fast startup for cloud deployments. By integrating CRaC experimentation, Payara is preparing for features that could dramatically improve startup and scaling of Java EE services in containerized environments. Additionally, Payara now caches remote public keys for JWT authentication (to handle outages of auth servers more gracefully). It’s worth noting that this is Payara’s first Community 7.x minor update after announcing the EOL of the older Payara 6 series in November (Community 6 is now end-of-life as EE 10 usage wanes). [infoq.com]
Apache TomEE 10.1.3 – Apache’s Jakarta EE 10 web profile server – got a maintenance release in December. TomEE 10.1.3 addressed some warnings when running on Java 21 and cleaned up its BOM (Bill of Materials) dependency descriptors. These tweaks make it smoother to use TomEE with modern Java and to manage its dependencies in Maven builds. While TomEE is on EE 10 (not EE 11 yet), it remains a lightweight option for those needing a Tomcat-based Jakarta EE runtime. [infoq.com]
In summary, the Java EE ecosystem is moving in step with the Java SE evolution: Jakarta EE 11 is being adopted and refined, Jakarta EE 12 is on the horizon, and all major servers are ensuring compatibility with Java 21 and 25. Enterprise developers can confidently use the newest Java features (like virtual threads, records, etc.) in their Jakarta EE applications as vendor support is there. And with experimental projects like CRaC and “Jakarta AI” in play, it’s clear that enterprise Java is aiming to stay cloud-friendly and future-proof.
While November delivered blockbuster releases (Spring Framework 7.0 / Spring Boot 4.0 GA, etc.), December 2025 was a month of consolidation in the Java ecosystem. Many frameworks issued minor version bumps and patches to polish their recent big releases or to maintain compatibility with the ever-evolving Java platform. We also saw steady progress in smaller projects and libraries that support the Java developer’s toolbox. Here’s a rundown of the key updates across popular frameworks and libraries this month:
After the huge Spring 7 and Boot 4 launch last month, the Spring team used December to address feedback and improve developer experience:
Spring Boot 4.0.1 was released on December 18 as the first patch update to the new Spring Boot 4 line. It includes 88 bug fixes, documentation improvements, and dependency upgrades. Early adopters of Spring Boot 4 reported a generally smooth upgrade from 3.x; this 4.0.1 release tidies up any rough edges and ensures greater stability. Noteworthy fixes likely include refinements to the new module-based auto-configuration system and adjustments for migrating Spring Boot’s testing utilities to the new modular structure. For enterprise Spring users, Boot 4.0.1 is a signal that the Spring 7/Boot 4 platform is production-ready and being fine-tuned. [spring.io]
Spring Framework 7.0.2 shipped alongside Boot 4.0.1. This is a maintenance release in the core Spring Framework, bringing minor fixes and performance tweaks. For example, Spring 7.0.2 resolved some edge cases in Kotlin coroutines support and eliminated a few unnecessary object allocations in the core framework. It will be incorporated in the Spring Boot 4.0.1 dependency stack. The quick turnaround of Spring Framework patches (7.0.1 came out late November, 7.0.2 in mid-December) shows the Spring team’s commitment to making the new generation as solid as possible. [infoq.com]
Spring Tools 5.0 went GA in early December, marking a major new release of Spring’s official IDE tooling. Announced by Martin Lippert on the Spring blog, Spring Tools 5.0 provides deep integration with Spring Framework 7 and Boot 4 for developers using Eclipse IDE, VS Code, or Theia. Crucially, Spring Tools 5 ushers the tooling into the era of AI-powered development: it has built-in support for GitHub Copilot and Cursor (AI pair programming assistants) directly within the Spring Tool Suite for Eclipse and in VS Code. This means Spring developers can get AI-generated code suggestions that are aware of Spring context, and even things like Spring-specific code completions via these assistants. Other features of Spring Tools 5 include support for the new Spring Boot 4 API versioning (the tooling can help manage different API versions of REST controllers) and functional bean registration introspection. Essentially, Spring Tools 5 aligns the IDE experience with all the new features of Spring 7/Boot 4, helping developers be more productive out of the box. Given the emphasis on AI, the Spring Tools team noted that this is “entering the age of AI” for IDE support, hinting that future releases will further leverage AI for things like automated code refactoring or smarter project insights. [infoq.com]
Spring AI 1.1.1 was released (a follow-up to Spring AI 1.1.0 GA from November). Spring AI is a newer Spring project that makes it easier to call AI models and LLM services from Java apps. Version 1.1.1 provided some small enhancements, notably a native integration with the official OpenAI Java SDK for more type-safe OpenAI API usage, plus new utilities for prompt filtering and memory management. Essentially, Spring AI is maturing rapidly – by incorporating the OpenAI SDK, developers get stronger typing when, say, calling ChatGPT models (no more constructing raw HTTP calls manually). Spring AI 1.1 also introduced an Arconia CLI to scaffold AI agents (as mentioned last month). All these improvements indicate that Spring is serious about enabling “GenAI” applications on the JVM, a theme that echoes across the Java landscape. (In fact, the SpringOne conference content from earlier in the year and various blog posts suggest Spring AI will be a key focus in 2026 for the Spring team.) [infoq.com] [blog.jetbrains.com]
Spring Shell 4.0.0-M2 was delivered as well. Spring Shell is a project for building interactive command-line shells in Spring applications. The 4.0 M2 release upgraded Spring Shell to depend on Spring 7/Boot 4 (moving to the new jakarta.* APIs) and introduced a more modular architecture for shell commands. It also fixed some issues with the annotation-based command registration (the @Command annotations) and improved null-safety via JSpecify, similar to what core Spring did. While niche, this project’s update is another piece of the puzzle in bringing the entire Spring portfolio up to date with the new Spring baseline. [infoq.com]
Spring Vault 4.1.0 Preview: The Spring team gave a sneak peek of upcoming Spring Vault 4.1 (part of the Spring ecosystem for integrating with HashiCorp Vault). In the Dec 22 Java roundup, it was noted that Spring Vault is introducing new interfaces VaultClient and ReactiveVaultClient to provide a safer abstraction over Vault operations. These enforce relative paths and prevent accidental use of absolute Vault paths, which is a nice hardening. Though 4.1.0 isn’t GA yet (expected early 2026), this shows Spring continues to refine its security integration libraries in line with best practices. [infoq.com]
Spring gRPC 1.0.0 was released GA in early December, marking an important addition to the Spring ecosystem. Spring gRPC provides Spring Boot integration for gRPC, allowing developers to easily create gRPC servers and clients with Spring configuration. The 1.0 release ensures compatibility with Spring Boot 4.0 and Spring Framework 7, uses a minimal Java 17 baseline (supporting up to Java 25), and has full null-safety (JSpecify) in its APIs. With Spring gRPC, you can expect starters and auto-configurations that simplify setting up gRPC services, security integration with Spring Security, etc. Notably, this 1.0.0 GA deprecates some auto-config features that will move to Spring Boot 4.1, indicating that by Spring Boot 4.1, gRPC support might be even more seamlessly integrated. For developers, the takeaway is that Spring officially supports gRPC now, which is great for microservice architectures using efficient binary RPC. [infoq.com]
All these Spring project updates reinforce that the “Spring 7 + Boot 4” era is fully underway and getting robust support. Early adopters who jumped on Spring 7 in November now have tooling (Spring Tools 5, IntelliJ updates) and a growing ecosystem of Spring projects (AI, Shell, gRPC, Security, etc.) all compatible with the new platform. The quick patches (like Boot 4.0.1) also show the framework’s responsiveness to community feedback. Spring’s team even blogged a multi-part “Road to GA” series on spring.io reflecting on the new features, underlining their importance. If you are in the Spring world, the end of 2025 is a great time to start planning an upgrade to Spring Boot 4. By early 2026, we anticipate a Spring Boot 4.1 release which will further integrate some of the external projects (bringing things like Spring gRPC autoconfig into Boot’s core) and possibly support newer Java previews. [blog.jetbrains.com]
Quarkus – Red Hat’s Kubernetes-native Java framework – continued its steady stream of maintenance releases on the 3.x line. In December, Quarkus 3.30.5 was released, marking the fifth incremental bugfix update since 3.30.0. These patches resolved a few noteworthy issues: for example, 3.30.5 fixed a tricky scenario where a context propagation bug caused a tracing MDC (Mapped Diagnostic Context) to vanish when using MicroProfile’s ManagedExecutor in conjunction with Quarkus’s OpenTelemetry extension. It also squashed an OutOfMemoryError in QuarkusMainTest (a testing harness for Quarkus CLI apps) by cleaning up loaded classes between tests. In short, Quarkus 3.30.x is being refined for production stability. [infoq.com]
More strategically, Red Hat signaled that Quarkus 3.27 (released in November) will serve as a long-term support branch, while active new development focuses on Quarkus 4. Although Quarkus 4 did not debut in 2025, we know it’s intended to target Jakarta EE 11 and Java 21+ exclusively (dropping support for older Java and Java EE APIs). One can expect Quarkus 4 in 2026 with perhaps a cleaner, slimmer core, leveraging virtual threads and the latest JDK features more pervasively. In the meantime, Quarkus users are advised to keep up with the 3.30.x patches (especially if they were affected by the security vulnerability CVE-2025-59250 in October – Quarkus 3.29.4 addressed that). By applying the December update 3.30.5, Quarkus applications get the benefit of all recent fixes as they head into the new year.
Micronaut, another popular JVM framework (known for its ahead-of-time compilation and low-memory footprint), also saw incremental releases in the 4.10 branch. Over the course of late November and December, the Micronaut team released versions 4.10.4, 4.10.5, and by the end of December Micronaut 4.10.6. These releases carried bug fixes and module updates – e.g., improvements in Micronaut’s MCP module (Micronaut’s Model-Context-Protocol integration, analogous to what Spring and Helidon are doing for AI/Agents) and updates to Micronaut’s SourceGen and Coherence modules. While no earth-shattering new features came in 4.10.x, the Micronaut team used this time to solicit feedback from the community on forward-looking changes: in particular, raising Micronaut’s baseline to JDK 25 for Micronaut 5. They opened discussions (via GitHub and social media) on requiring Java 25 and Kotlin 2.3+ for the next major version, in order to leverage new JDK features like Scoped Values (from JDK 21) in the framework’s internals. According to Micronaut’s lead, community feedback has been positive for moving the baseline forward. This suggests that by the time Micronaut 5 comes (likely in 2026), Java 25 might be the minimum – a sign of how quickly modern Java features are being adopted by cutting-edge frameworks. For now, Micronaut 4 is compatible with Java 17–21 (and officially 25 as well), enabling folks to build GraalVM native images and microservices with the confidence of recent Java support. In the big picture, Micronaut’s trajectory remains aligned with Spring and Quarkus: embrace the newest Java, Jakarta EE, and concurrency features to maximize performance. We’ll watch for Micronaut 5 news in the coming months. [infoq.com]
Apache Groovy & Grails: In the Groovy community, a significant milestone was the release of Grails 7.0.0 (announced in late October under the Apache Foundation). As noted in the November Pulse, Grails 7 modernized the venerable web framework by rebuilding on Micronaut 4 and updating GORM. By December, Grails 7 adoption has started among the legacy Grails user base, giving those applications a path to run on Java 21 with modern libraries. There were no new Grails releases in December, but the impact of Grails 7 was highlighted in community discussions as one of 2025’s notable open-source achievements： it revitalized a framework that many thought was stagnating. Alongside, the Spock Framework 2.4.0 (a testing/spec framework for Groovy and Java) finally hit GA in December after three years of development. Spock 2.4 adds support for Groovy 5.0 and introduces new testing features like the @Snapshot annotation for state verification and an IBlockListener extension point for custom test reporting. For developers using Groovy, Spock is a go-to tool, so having it updated for Groovy 5 ensures the Groovy ecosystem remains up-to-date. [infoq.com]
Java MicroProfile & EE related: The Jakarta EE 10/11 era continues to influence related projects. Apache Camel 4.x (the integration framework) didn’t have a new release in Dec, but it was already updated in late fall to ensure compatibility with Java 25 and virtual threads. Eclipse Vert.x, Helidon, and MicroProfile implementations are similarly issuing minor updates to lock in Java 21/25 support and incorporate any relevant EE 10/11 changes. For instance, Infinispan 16.0.5 (released in December) added initial support for Spring Framework 7 and Spring Boot 4 in its caching APIs, ensuring that Spring+Infinispan users can upgrade without issues. Infinispan also fixed some encoding bugs (with ProtoStream and JavaSerializationMarshaller) in these releases. These kinds of updates, while low-level, are crucial for smooth interoperability between frameworks as the entire ecosystem shifts upward to new baselines. [infoq.com]
Build Tools – Gradle and Maven: In the build automation arena, both major tools are nearing big transitions:
Gradle: The Gradle team is working on the 9.3 release. By late December, they published the second Release Candidate of Gradle 9.3. According to release notes, Gradle 9.3.0 will introduce nicer test reports (including an improved HTML test report that better organizes results from parameterized or nested tests) and a new “problems” reporting API that surfaces build issues in a clearer way in console output. There are also enhancements to the Gradle Kotlin DSL and some performance tuning. Gradle 9.2 had already added support for ARM64 on Windows and configuration caching improvements, so 9.3 builds on that. We can expect Gradle 9.3 final in early 2026. Notably, Gradle is well-poised for Java 25 – it runs on Java 17+ and can build projects targeting Java 25 without trouble. The Gradle team’s bigger project (likely Gradle 10 in the future) is an initiative to use the tool’s recent configuration cache and parallel execution features to drastically speed up multi-project builds. Gradle continues to evolve in small iterative steps, and these RC releases are part of that cadence. [infoq.com]
Apache Maven: The Maven community has been eagerly awaiting Maven 4.0, the first major version bump to Maven in over a decade. In November, Maven 4.0.0-RC4 and RC5 were released for testing, and in December that remained the state: no GA release of Maven 4.0 yet, but RC5 is the latest. As of the end of 2025, the Apache Maven project has not announced an exact GA date, but many believe it’s imminent (possibly in January 2026). Maven 4 brings significant changes: it requires Java 17+ to run, it introduces a new publishing API and Build/Consumer POM separation (internally flattening the POM for consumers), and overall improves performance and error messages. The fact that Baeldung published a detailed “What’s New in Maven 4” article on Dec 31 shows that the community is gearing up. In practice, if you’re a Maven user, you should be testing your projects on Maven 4 RC5 now – a lot of plugins have new versions to support Maven 4. The good news is that Maven’s maintainers aim to keep Maven 4 compatible with existing Maven 3 POMs (it upgrades the model version to 4.1.0 but will still build 4.0.0 POMs). Expect Maven 4.0.0 final early in 2026, which will officially bring Maven up to parity with modern Java (it will even support publishing to Java’s module path properly, among other improvements). For December, the Maven story is “almost there, just testing and polishing.” Many companies (and CI tools) have already started supporting the Maven 4 release candidates so that the ecosystem is ready on day one of GA. [baeldung.com] [baeldung.com], [baeldung.com]
Gradle vs Maven usage trends: anecdotally, Gradle and Maven remain both widely used in the Java world, with Maven still dominant for open-source and enterprise builds, but Gradle strong in Android and growing in general Java thanks to its performance focus. The coming Maven 4 and Gradle 10 in 2026 will make it interesting to watch if Maven can close some gaps (like build speed) or if Gradle will continue to pull ahead. For now, in December, both communities show a healthy rate of improvement.
Other Libraries and Releases: A few additional noteworthy updates in the Java ecosystem during December:
LangChain4j 1.10.0 was released, marking the first non-beta (“formal”) release of this library. LangChain4j is a Java port inspired by the Python LangChain, aimed at helping developers orchestrate LLM calls and build “agents” that use tools to fulfill tasks. Version 1.10.0 adds an AgentListener/AgentMonitor API to allow monitoring what the AI agents are doing (useful for logging or debugging prompt sequences). It also adds convenient discovery of available models (OpenAI, Anthropic, etc.) programmatically. This is significant because it shows the Java community’s continued investment in AI libraries – LangChain4j has rapidly evolved throughout 2025 (it went through 18 beta releases). By solidifying a 1.10 release, it’s signaling readiness for broader use. With Spring AI and LangChain4j, Java developers now have credible options to build AI-powered applications entirely in Java, which wasn’t the case a year ago. [infoq.com]
Seed4J 2.2.0 came out in December. Seed4J is the new name for JHipster Lite, a lightweight app blueprint/generator for modern Java microservices. The 2.2.0 release aligns Seed4J with Spring Boot 4.0 – it updated its project templates to use Spring Boot 4 and replaced some testing utilities (it dropped the old Spring TestRestTemplate in favor of a new CucumberRestTest abstraction). Interestingly, it also temporarily disabled its LangChain4j integration modules until they can be made compatible with Spring Boot 4. This underscores how frameworks like JHipster/Seed4J are adapting to the new Spring and Java versions. The JHipster main framework (not just Lite) is also undergoing changes: a JHipster 9.0.0 first beta was announced in early December, featuring a complete blueprint rewrite in TypeScript and support for JDK 25 and Node.js 20+. JHipster 9 aims to modernize the OSS generator which many companies use for quickstarting Spring + Angular/React projects. It’s notable that JHipster 9 will fully embrace Java 25 (the beta requires JDK 25). All in all, these project generator tools are making sure that if you start a new project in 2026, it will be on the latest and greatest stack. [infoq.com] [infoq.com]
TornadoVM 2.1.0 was released, following up the big 2.0 release (which came out around November). TornadoVM is an exciting project for executing Java (and polyglot) workloads on GPUs and accelerators. Version 2.1.0 in December brought specific improvements like fixing half-precision float conversion issues and adding new GPU-optimized matrix multiplication routines. The TornadoVM team also released GPULlama3.java 0.3.0, an open-source project integrating the upcoming Llama 3 AI model with GPU acceleration via TornadoVM. This project achieved faster FP16 (half precision) inference on NVIDIA GPUs, demonstrating Java’s potential in AI inference use cases with the right tooling. While niche, it’s pretty cool to see Java code driving GPU workloads for machine learning. These developments hint that 2026 might see more convergence of Java with HPC/AI. [infoq.com]
Apache Tomcat & Friends: The Apache Tomcat team put out Tomcat 11.0.15, 10.1.50, and 9.0.113 in December. These were routine maintenance releases (e.g., fixing some SSL configuration edge cases and a clustering regression). Tomcat 11 is still in alpha (implements Servlet 6.1, aligning with Jakarta EE 11), but no major issues were reported. It’s notable that Tomcat 9 (servlet 4.0) is still being updated, reflecting that many are still on older Java EE generations. Apache also released TomEE 9.1.3 / 10.1.3 as mentioned earlier, and Apache Kafka rolled out version 3.6 (with Java 21 support). Additionally, the Spring Integration project reached 6.2, and Hibernate Search hit an RC for 8.2 as per the news, ensuring compatibility with Hibernate ORM 7.2. [infoq.com] [infoq.com]
Overall, December’s framework and library updates were about refinement and preparation. The Java ecosystem is clearly standardizing on Java 17/21/25 and Jakarta EE 11. Framework maintainers are making sure their tools run well on those versions, and that any new features (like virtual threads, records, pattern matching) are leveraged or at least not broken. At the same time, the innovation focus has shifted to new horizons like cloud optimization (Quarkus 4, CRaC), AI integration (Spring AI, LangChain4j), and developer productivity (Spring Tools 5 with AI, better build tools). It’s an exciting balance: Java developers get a stable foundation and new toys to play with.
The end of 2025 also brought updates to the tools that Java developers use every day – IDEs, build systems (covered above), and other dev infrastructure – ensuring that working with the latest Java and frameworks is as smooth as possible.
IDE Support for New Java & Spring: Both JetBrains and the Eclipse Foundation delivered year-end releases of their flagship IDEs:
IntelliJ IDEA 2025.3 was released (the third major update of the year for IntelliJ). This version provides full support for Java 25 and the newest language features (e.g. it recognizes Java’s string templates or unnamed classes if those previews are enabled). More notably for enterprise developers, IntelliJ 2025.3 adds built-in understanding of Spring Framework 7 and Spring Boot 4 features. It can handle the new multiple Spring Boot starter modules (showing developers only the auto-configurations actually in play), supports Spring’s API versioning annotations in its inspections, and offers code insight for new Spring APIs like @HttpServiceClient interfaces. JetBrains also updated IntelliJ’s Spring Data JDBC tooling – you can now auto-generate entity classes from an existing database schema and even generate migration scripts (Flyway/Liquibase) from those entities. These improvements, along with usual performance fixes, mean that developers upgrading to Spring Boot 4 have first-class IDE assistance. Additionally, IntelliJ 2025.3 improved its Gradle 9 integration and Docker support for Java, and fixed a number of UI issues to keep the developer experience polished. [blog.jetbrains.com]
Eclipse IDE 2025‑12 (December 2025 quarterly release) came out as well. In this release, the Eclipse JDT (Java Development Tools) added support for Jakarta EE 11 development, including the new jakarta.* APIs and schema recognition. This is important for developers working on Jakarta EE 11 or converting Java EE 8 code to Jakarta namespaces. Eclipse 2025-12 also updates its Java tooling for JDK 25, so that features like record patterns or virtual threads are understood by the debugger and content assist. Meanwhile, the Spring Tools 5 mentioned earlier is actually an Eclipse plugin set – it comes bundled with the Spring Tools Suite (an Eclipse distribution). So Eclipse users can install Spring Tools 5.0 to get all the Spring 7/Boot 4 support inside Eclipse. The synergy of these updates ensures that even as IntelliJ dominates among many Java devs, those using Eclipse (or even VS Code) are not left behind when adopting the latest frameworks. [manorrock.com]
Visual Studio Code (Java Extension Pack): Microsoft’s VS Code, combined with the Red Hat Java extension and others, has become a popular lightweight editor for Java. Throughout 2025, the VS Code team shipped regular improvements, and by December, VS Code’s Java support fully handles Java 21 and 25 (including project Loom’s virtual threads in the debugger). The December update of the Extension Pack introduced faster startup for the language server and better support for Lombok and Testcontainers (useful in modern dev workflows). While not a single “big bang” release, VS Code’s Java tooling at year-end is in excellent shape for those who prefer an editor approach. Also, note that Spring Tools 5 has a VS Code extension as well, so VS Code users can leverage Spring-specific features on par with Eclipse.
Quality of Life Tools: Aside from IDEs, a number of developer tools saw updates:
JUnit 5.11 was released in December, bringing some minor enhancements to the ubiquitous testing framework. It introduced the ability to order test classes at runtime and improved test instance post-processing extensions. Nothing major, but JUnit continues its incremental march.
Mockito 5.5 and AssertJ 3.24 also dropped toward year-end, keeping Java testing libraries compatible and up-to-date. These likely include adjustments for records and final classes which become more common with new Java versions.
Checkstyle 10.12 and SpotBugs 4.8 updates provided static analysis support for Java 21/25 syntax, which is helpful for teams enforcing code standards.
In the build/test space, Pact JVM (consumer-driven contracts) got an update supporting JDK 21, and Gatling (load testing) released version 3.10 with Scala 3 support (since some Java teams use Gatling via Scala).
Collectively, these tools ensure that as a Java developer, you won’t hit a snag using the latest Java or frameworks – your IDE will autocomplete new APIs, your linters understand new syntax, and your test libraries can test modern code constructs.
Cloud Deployments and DevOps: While not a tool per se, it’s worth noting that cloud providers continued to improve their Java offerings in late 2025:
AWS Lambda announced GA of their Java 21 runtime in December, so serverless functions can now run on Java 21 (with plans for Java 25 support in preview). This is key for those building FaaS with Java.
Azure Functions similarly beta-tested a Java 21 runtime. On the container side, Azure Spring Apps service rolled out support for Spring Boot 4 apps in December updates, making sure Azure’s managed Spring service is ready for the new Spring generation.
Google Cloud updated its Cloud Run and App Engine environments to support JDK 21 and 25. Plus, all major clouds have made Microsoft’s Java on VS Code dev containers available for remote development.
These aren’t development tools in the traditional sense, but they show the DevOps side keeping pace so that deploying Java 25/Spring 4 apps is fully supported.
In summary, Java’s developer tooling ecosystem ended 2025 in lockstep with the platform’s progress. Whether you prefer IntelliJ or Eclipse or VS Code, Spring or Micronaut, Maven or Gradle, the tools are ready for Java 25, Jakarta EE 11, Spring Boot 4, and beyond. This level of support is crucial – it reduces friction for teams adopting new tech. It’s apparent that tool vendors and open-source maintainers have been testing against early-access JDKs and framework milestones all year long. As a result, when those technologies hit GA (like Java 25 in September or Spring 7 in November), the IDEs, build plugins, and analyzers are almost immediately compatible. This is a testament to the vibrancy and coordination in the Java ecosystem.
December is often a quieter period for conferences and announcements, but the Java community still had plenty of knowledge sharing and reflection to cap off the year. Here are some community and industry highlights from Dec 2025:
InfoQ Java Trends Report 2025: One of the most insightful publications this month was InfoQ’s annual Java Trends Report, published on December 11. This report, authored by Java Champions and InfoQ editors, offers a high-level look at where Java is and where it’s headed, based on the “buzz” and adoption they’ve observed throughout 2025. Some key takeaways from the 2025 report: [infoq.com]
“AI on the JVM accelerates.” The report notes that 2025 saw an explosion of interest in bringing AI and machine learning capabilities to Java. It highlights new frameworks like Embabel (an “agent” framework by Rod Johnson, of Spring fame) and Koog (an open-source Kotlin-based agent framework by JetBrains) that emerged in 2025 to enable building AI agents in JVM languages. Along with Spring AI and LangChain4j, these tools are driving rapid adoption of AI features in Java apps. In essence, what was once mostly the domain of Python is now becoming accessible in Java – and the community is very interested. Many Java shops are experimenting with LLM-based features (like intelligent assistants or code generation) integrated into their Java systems. [infoq.com]
“Java 25 anchors a modern baseline.” Java 25’s release (and even Java 21 before it) is seen as a turning point where the Java ecosystem has largely moved its baseline up. All major frameworks now require Java 17 or later, and many (like Spring 7, Quarkus 4 upcoming, Micronaut 5 upcoming) are targeting Java 21+. This means features like records, sealed classes, and virtual threads are widely available to developers via their frameworks. The report emphasizes Java 25’s improvements in readability (e.g., string templates), concurrency (virtual threads, structured concurrency), and performance, which collectively make a compelling case to upgrade. Essentially, Java 25 (LTS) is seen as the new stable foundation for the next few years. [infoq.com]
“Modernization surges.” 2025 saw many organizations prioritize the modernization of legacy Java applications. With Java 8 reaching end of public support, companies accelerated efforts to move old apps (some still on Java 8 or even 7) to newer Java versions or to migrate from antiquated technologies (old app servers, outdated libraries) to modern equivalents. Tools like OpenRewrite were highlighted as game-changers in this domain. OpenRewrite provides automated refactoring recipes (for instance, converting javax. imports to jakarta. for EE -> Jakarta migration, or updating deprecated Spring Boot APIs). InfoQ’s report notes that OpenRewrite “emerged as the dominant automation tool” for code modernization. The takeaway: companies are actively refactoring and rebuilding to stay on current Java, often motivated by security and support considerations, and the ecosystem of tools to assist in that is maturing. [infoq.com] [infoq.com], [infoq.com]
“Enterprise Java advances.” The report acknowledges the progress in enterprise Java: Jakarta EE 11 became stable and widely implemented in 2025, and work on Jakarta EE 12 began proactively (with plan reviews for 24 specs during 2025). Notably, four new specs are being added in EE 12 (like Jakarta Query as mentioned). The projection is that Jakarta EE 12 will focus on consistency and configuration improvements (as previously reported by InfoQ) and likely integrate more with the cloud-native world. Also, the fact that multiple Jakarta EE 11 implementations (e.g., Open Liberty, Payara, WildFly) were available quickly shows a strong vendor commitment. The enterprise world, often slower to move, is nonetheless steadily adopting these standards, keeping Java relevant for traditional large-scale systems. [infoq.com]
“Community & deployment shifts.” Another interesting trend is that Java community engagement is growing again – possibly due to excitement around new features and use cases like AI. Conferences in 2025 (like Devoxx BE, J-Fall) were very well attended, and user groups (JUGs) saw strong participation, perhaps as pandemic-era lulls faded. The InfoQ editors also noted that many enterprises are exploring hybrid or on-premises cloud deployments instead of exclusively public cloud. In other words, Java’s strength in on-prem environments (thanks to its stability and the fact that companies can run Java anywhere) is being rediscovered as companies seek to optimize costs or comply with data regulations. Technologies like Kubernetes and platform services (e.g., Azure’s and AWS’s managed Java services) are enabling more flexible deployment models, and Java fits well into that as it’s not tied to any single cloud. This trend was subtle but reflects that Java is often the runtime of choice in private cloud scenarios, giving it an edge in certain industries. [infoq.com]
The InfoQ trends report is essentially a yearly “state of Java”. For 2025, it paints a picture of a language/platform that is both revitalized and evolving. The excitement around AI, the major version releases (Java 25, Spring 7), and the push to eliminate technical debt (modernize legacy code) all point toward a Java ecosystem that’s actively reinventing itself rather than resting on laurels. As we head into 2026, these trends suggest Java will remain a cornerstone technology, but with new facets (like AI, cloud-native optimizations) becoming part of the mainstream Java story.
Year-End Blog Posts & Resources: Besides InfoQ, many community thought leaders published their year-in-review analyses and technical deep-dives:
JetBrains Java Annotated Monthly (Dec 2025): The IntelliJ team’s monthly Java newsletter had guest author Siva Katamreddy curating content. It recapped all the big news (JDK 26 JEPs targeted, Spring Boot 4 GA) and pointed readers to resources like Dan Vega’s YouTube series on Spring Boot 4 new features. It’s a handy digest for those who might have missed November’s rush. It also included links to the Inside Java Newscasts #100 and #101 (covering Project Valhalla’s progress on value classes and the JDK’s new reflection warnings), and other tutorial articles. [blog.jetbrains.com]
Baeldung Guides: Baeldung.com published several relevant articles, including “Spring Boot 4 & Spring Framework 7 – What’s New” (in mid-November, but circulating in Dec) which nicely summarizes the API changes and improvements for developers migrating to Spring’s new versions. On Dec 31, Baeldung published “What’s New in Maven 4”, which was perfectly timed for those preparing for Maven’s release – an example of how community educators are helping devs get up to speed even before tools officially drop. These kinds of blog posts are invaluable for dissemination of knowledge. [baeldung.com]
Thought Leadership on AI & Java: A number of Java luminaries wrote about AI’s impact. For example, David Griffiths posted “Software Development in the Time of Strange New Angels” (an essay on how AI assistants are changing coding), and zed.dev had an article “AI’s 70% Problem” discussing how AI often gets things partially right and the implications of that. These were shared in JetBrains’ newsletter and on social media, sparking discussions about how tools like GitHub Copilot fit into a disciplined development process. The consensus seems to be that AI is a powerful aid but not a replacement – a theme echoed by many in the Java community. [blog.jetbrains.com]
Community Awards and Events: The Dutch Java User Group (NLJUG) announced their 2025 Innovation Award at J-Fall in November (won by a company called Maqqie for their Java solution). In December, some local JUGs held holiday meetups or mini-conferences. For instance, the Java Developers’ Conference (JDC) 2025 took place on December 6 in Bangladesh (as an in-person event after a hiatus), showing Java’s global community aspect. And on December 2, the Eclipse Foundation hosted the JakartaOne Livestream 2025 (an online conference for Jakarta EE), where community leaders discussed Jakarta EE’s road ahead (this coincided with the Jakarta EE 12 work). These events, while not huge like a Devoxx, indicate that knowledge sharing in the Java world persists year-round.
Vendor Announcements: Companies like Azul and Adoptium posted year-end updates. Azul systems highlighted that its customers were migrating to Java 21/25 on Azul’s platform, and Adoptium’s Eclipse Temurin published stats on millions of Java download requests, demonstrating the reach of free OpenJDK builds. Also, Oracle’s Java engineering team participated in several events (like the Oracle Developer Live series continued through fall), and by December Oracle was prepping messaging for the upcoming Java 26 features to drum up early interest.
Microsoft for Java: Microsoft’s advocacy for Java (through their Microsoft for Java Developers blog) continued. They wrote about Project Panama progress (foreign function & memory API, etc.) and even hosted a panel on “Java in the cloud” that touched on using Azure’s Arm-based VMs with Java for cost efficiency. This shows how even historically non-Java companies are investing in Java content, reflecting Java’s broad relevance.
All told, the community vibe at the end of 2025 was positive and forward-looking. Java developers are excited about new possibilities (like combining Java with AI or using new language features to write cleaner code), and there’s a sense of confidence that the platform is evolving in the right direction. The year-end retrospectives largely celebrated Java’s 2025 accomplishments – from the successful delivery of a major LTS (JDK 25) to the ecosystem’s embrace of modernization – and set an optimistic tone for 2026.
One common thread in community discussions was developer advocacy for upgrading: influencers repeatedly encouraged those still on older Java or Spring versions to plan upgrades, citing the tangible benefits seen by early adopters. With official support for Java 8/11 ending, 2025 was likely the last year where laggards could comfortably stay put; in 2026, upgrades won’t be optional for many. Fortunately, the community produced plenty of guides, tools, and success stories to help others make that leap.
In terms of security, December 2025 was relatively quiet for Java, which is a welcome respite given some of the high-profile issues of recent years. No new “Log4Shell”-style zero-day hit the headlines, and no critical CVEs were disclosed in core Java or major frameworks during the month. Instead, the focus was on applying the fixes released in the October CPU and other recent patches, as well as preparing for upcoming security releases:
Oracle’s January 2026 Critical Patch Update was on the horizon. This CPU will contain the final public fixes for Java 8 and 11 (as mentioned) and updates for Java 17, 21, and 25. The Java team and security experts used blogs and forums to remind developers to stay current: e.g., ensure you’ve applied October’s CPU (which was Java 25.0.1, 21.0.1, etc.) and be ready to apply the January CPU promptly when it arrives. Given that older Java versions often linger in organizations, outreach about the end of free support for 8/11 has a security angle – running unpatched Java in 2026 would be risky.
JDK Hardening: The OpenJDK project continues to harden the Java runtime. A noteworthy change coming in JDK 26 (not a fix but a protective measure) is the warning on deep reflection we discussed. This is essentially a security improvement, as it will discourage libraries from using unsafe reflection tricks that could break strong encapsulation or allow access to non-public data. Over time, eliminating such tricks will reduce the attack surface of the JVM (making it harder for an attacker to use reflection to reach into internal JDK classes, for instance). [manorrock.com]
One could say that security in December was in a “monitor and maintain” phase – address known issues, ensure dependencies are updated, and no news is good news. The lack of new Java CVEs in December meant developers could focus on functionality and upgrades without emergency distractions. It’s a stark contrast to Decembers past (e.g. December 2021 with Log4j), and undoubtedly a relief.
Going into the new year, developers are advised to keep their Java environments updated (at least to JDK 17u and 21u latest, or JDK 25) and to upgrade frameworks to versions that have the latest patches. For instance, Spring Boot 4.0 has newer, more secure defaults compared to older Spring 3.x, and Quarkus 3.30+ is safer than Quarkus 3.13 was a year ago. The good news is that with the systematic quarterly updates from Oracle (and similarly timed updates from other OpenJDK distributors), the Java platform has a predictable and steady security refresh cycle – something enterprises can plan around.
To sum up, Java closed out 2025 in a secure and stable state, with all known serious vulnerabilities addressed and no new major threats looming at year’s end. This sets a solid foundation heading into 2026, where vigilance will continue but hopefully without any crisis-level events.
December 2025 capped off an eventful year for Java on a high note. The Java ecosystem demonstrated a remarkable balance of innovation and stability: even as big changes (like Java 25, Spring Boot 4, Jakarta EE 11) rolled out, the community absorbed them and reinforced them with tooling, patches, and learnings. In this final month, we saw the Java platform bridge the present and the future – JDK 26’s upcoming features were firmed up while Java 25 solidified its role as the production workhorse. Major frameworks entered a new era (the Spring 7 generation) and are already proving their value, and enterprise Java is evolving to tackle next-frontier problems like AI integration and cloud checkpointing. Meanwhile, the core principles that have always defined Java – performance, reliability, backward compatibility, security – remain front and center, as evidenced by the ongoing performance tuning and security hardening efforts. [manorrock.com]
Going into 2026, Java developers have a lot to look forward to. By March, we anticipate Java 26 will be released with those 10 new features, bringing incremental but meaningful improvements (especially for performance and language consistency). Frameworks like Quarkus 4 and Micronaut 5 are likely to arrive, which will push Java further into cloud-native and AI use cases. Jakarta EE 12 will progress through milestones, fleshing out how enterprise Java can standardize things like Jakarta Data and perhaps early aspects of AI/ML in the platform. The ecosystem will also continue the drumbeat of modernization – perhaps by the end of 2026, Java 17 and 21 will nearly eclipse Java 8 in usage, finally retiring a decade of accumulated technical debt.
One theme is clear: Java is not standing still. The language and platform keep adapting – embracing modern paradigms (functional style, reactive, now AI) and addressing developer needs (better syntax, better tooling). And yet, Java also preserves what works – large swaths of existing code run unchanged on the latest JVM with better performance than ever, and investments in the ecosystem (libraries, knowledge, skills) carry forward. This dual strength is why Java’s trajectory remains strong after 30 years.
If 2025 was about shipping major releases, 2026 will be about operationalizing and optimizing them. Expect to see more real-world stories of Java 25 in production, Spring Boot 4 powering new microservices, and companies achieving feats like 10x throughput with virtual threads or cutting cloud costs with native images and CRaC. The groundwork laid in 2025 will yield results.
Finally, it’s worth appreciating the Java community itself – from contributors on OpenJDK mailing lists to framework maintainers to those sharing knowledge at JUGs and online. The collaborative effort is what made this “Pulse on Java” so full of news! We can confidently say that Java’s ecosystem is healthier than ever. So as we close the book on 2025, let’s raise a toast to Java’s progress and to an exciting year ahead.
Happy New Year! 🎉 Here’s to a productive and innovation-filled 2026 for Java developers everywhere.