Your AI-generated monthly roundup of Java framework and platform updates. Dive into the key releases, news, and trends that shaped the Java ecosystem in October 2025.
October 2025 kept up Java’s torrid pace following the Java 25 release in September. This month saw Java 25 enter its post-GA maintenance phase (with the first critical patches rolled out) even as OpenJDK developers pushed ahead on Java 26. In parallel, major Java frameworks hit milestones: Apache Grails 7.0 reached GA, the Spring portfolio delivered first release candidates for its next generation (Spring Boot 4.0, Spring Framework 7.0, and more), and both Quarkus and Micronaut added new features to ride Java’s latest capabilities. The enterprise Java world began shaping Jakarta EE 12 – including work on a groundbreaking Jakarta AI specification – while application servers and libraries updated to support Java 25 and Jakarta EE 11. Meanwhile, the community buzzed with Java+AI innovations and event highlights: Oracle’s big AI World 2025 conference showcased Java 25’s relevance to AI/cloud, and excitement grew for JavaOne’s return in 2026. Below is an overview of this action-packed month across the Java landscape.
| Category | Key Updates and Highlights |
|---|---|
| Java SE Platform | JDK 25.0.1 was released as part of Oracle’s October Critical Patch Update, addressing security vulnerabilities in Java 25 and earlier LTS versions [infoq.com]. With Java 25 now in wide use, the focus turned to OpenJDK JDK 26 development – multiple JDK Enhancement Proposals (JEPs) were moved to “Proposed to Target” for JDK 26 this month, including another preview of Structured Concurrency and an 11th incubator of the Vector API [infoq.com]. Early-access builds for JDK 26 (build 22 by late October) came out with steady fixes and improvements [infoq.com]. |
| Enterprise Java | Planning for Jakarta EE 12 picked up: the new Jakarta Query 1.0 specification had its first milestone, unifying JPQL and JDQL query languages for data access in Jakarta EE [infoq.com]. The Jakarta EE Platform project scheduled Milestone 2 for December, aiming to lock down EE 12 content [infoq.com]. Notably, a proposal for a Jakarta “Agentic AI” specification began creation review (to conclude in early November) with overwhelming community support [infoq.com]. In the meantime, enterprise runtimes are keeping pace with Java 25 and Jakarta EE 11: e.g. Open Liberty’s October beta (25.0.0.11) added a new MCP-based AI integration feature to let Java apps expose functionality to LLMs [infoq.com], and other servers like GlassFish and WildFly continued their work toward full EE 11 compatibility. |
| Frameworks & Libraries | Spring Framework 7.0 progressed to a third (and likely final) release candidate, fixing bugs and polishing new features (like the RestTestClient) ahead of an expected GA in late November [infoq.com]. The broader Spring ecosystem entered next-gen RC stage together: Spring Boot 4.0 RC1 introduced support for the new RestClient API and completed codebase modularization to shrink typical apps’ size [infoq.com]; first RCs arrived for Spring Security 7, Spring Batch 6, Spring for GraphQL 2, Spring Integration 7 and more, bringing Java 21+ support and numerous API improvements. The Apache Grails 7.0.0 web framework hit GA under the Apache umbrella, its first stable release since moving to ASF – updating Grails to work with the latest Spring Boot (and even offering an option to use virtual threads) while retiring outdated modules [infoq.com], [infoq.com]. Red Hat’s Quarkus saw version 3.29.0.Final (early October brought 3.28.x fixes, followed by 3.29 in late October): it added support for using multiple cache backends simultaneously and introduced support for the Debug Adapter Protocol in its Qute templating extension [infoq.com], alongside the usual performance tweaks and dependency updates. The Micronaut 4.10.0 framework arrived, debuting a new Micronaut MCP module to integrate with the Model Context Protocol (for AI/LLM use cases) and replacing some low-level APIs (introducing a ReadBuffer abstraction for I/O) for improved performance [infoq.com]. In the Scala/FP realm, Akka 2.8.4 (now under open-source license) and Play Framework 2.9 had maintenance releases (ensuring compatibility with Java 17+), and the lightweight Ktor 3.3.1 server toolkit upgraded to Kotlin 2.2 and fixed bugs in its SSE client handling [infoq.com]. |
| Dev Tools | The build toolchain kept up with Java’s evolution. Gradle 9.2 was released, bringing support for running builds on Windows/ARM64 environments and enhancements to custom component publishing and error reporting [infoq.com]. JReleaser 1.21.0 came out with new automation tricks – for example, it can now announce releases on Reddit via the Reddit API, and it added an option to enforce immutable release tags on GitHub, alongside fixes to PGP signing workflows [infoq.com]. The project formerly known as JHipster Lite saw its rebranding to “Seed4J”, coinciding with a 2.1.0 release that adds full JDK 25 support and UI/health improvements for generated apps [infoq.com]. Testing and QA tools had incremental updates as well (Selenium and JUnit got minor upgrades), ensuring a smooth path for teams adopting the new Java 25. |
| Community & Events | Oracle AI World 2025 (Oct 17–19, Las Vegas): Oracle’s big fall conference (rebranded from CloudWorld) devoted a track to Java – highlighted by a talk from Java engineering VP Georges Saab, who showcased how Java 25’s features (like faster startup, virtual threads, and new APIs) empower AI and cloud-native development [dev.java]. The session underscored Java’s ongoing relevance in the AI era, tying in with Oracle’s messaging of Java as a key enterprise AI platform. JavaOne 2026 Revival: Oracle opened the Call for Papers for JavaOne’s return in 2026 (scheduled for March 17–19, 2026 in Redwood Shores, CA). This will be the first standalone JavaOne in years, and the community is abuzz with anticipation. Community Buzz: October saw no slowdown in Java content – user groups and conferences (JFall in Netherlands, Joker in Russia, etc.) held Java 21/25 adoption sessions, and bloggers tackled Java 25’s new features in depth. For example, Foojay’s “Java 25: Ready to Perform” article detailed runtime and GC enhancements in JDK 25 [blog.jetbrains.com], while others debated the “nice vs. meh” features in the release. On the AI front, Spring creator Rod Johnson unveiled Embabel as an open-source JVM agent framework for building AI agents (mixing LLM prompts with Java code), sparking discussion on Java’s role in the AI tooling landscape [hackernoon.com]. And in the open-source world, Apache’s stewardship of Grails and the Eclipse Foundation’s incubation of projects like Eclipse DataGrid illustrate the community’s commitment to keeping Java vibrant and adaptable. |
🌱 Spring Embraces Java 25+: The Spring ecosystem spent October gearing up for its next major versions, all designed for the modern Java era. The flagship Spring Framework 7.0 reached its third (and likely final) release candidate, squashing bugs and finalizing new features like the RestTestClient for easier REST interface testing. With Spring Framework 7 nearing GA, the Spring Boot 4.0 pipeline also hit a significant milestone – Spring Boot 4.0.0 RC1 was released, incorporating support for Spring 7’s new HTTP interface clients and completing a major internal refactoring to modularize Boot’s codebase. This modularization trims the default footprint of Spring Boot apps and provides more targeted auto-configuration, so developers get leaner applications with only the necessary pieces. Spring Boot 4 aims to align with Java 21+ features out-of-the-box, positioning it well for JDK 25 deployments. [infoq.com] [infoq.com]
But Spring Boot was just one of many Spring projects advancing: virtually all major Spring sub-projects hit 4.0/8.0 release candidates in October. To name a few, Spring Security 7.0 RC1 introduced a new annotation-based model for multi-factor authentication (e.g. an @EnableGlobalMultiFactorAuthentication to easily bootstrap MFA in apps); Spring Batch 6.0 RC1 added graceful shutdown for jobs and better support for Staged Event-Driven Architecture (SEDA) messaging patterns for high-throughput batch processing. Spring for GraphQL 2.0 RC1 debuted convenient Kotlin extensions and a new HTTP header interceptor for GraphQL clients. Even behind-the-scenes libraries like Spring Integration, Spring AMQP, Spring Session, Spring Modulith, Spring REST Docs, and others published RC1s with numerous enhancements (ranging from new AMQP adapters and Kafka improvements to documentation overhauls). The common theme is Java 25 readiness – many of these Spring 4.0 projects now require JDK 21+, leverage Jakarta EE 10+, and adopt updated dependencies (e.g. Spring Vault 4.0 RC1 is explicitly built with JDK 25, Spring Framework 7, JUnit 6, and Jackson 3.0 in mind). The flurry of Spring releases indicates that the Spring team is aligning its ecosystem for a smooth transition into the post-Java 21 world, embracing features like virtual threads (supported in Spring’s concurrency libraries) and new language enhancements. Spring enthusiasts can expect final releases around late 2025, but the RCs are already usable for testing on Java 25. [infoq.com] [infoq.com], [infoq.com]
🧩 Apache Grails 7.0 GA: The Groovy-based web framework Grails marked a major milestone in October by releasing Grails 7.0.0 GA. This is the first stable Grails release since the project’s move to the Apache Software Foundation, and it represents a rejuvenation of the framework for modern Java. Grails 7 is built atop Spring Boot 3.x (with experimental support for Boot 4/Spring 7 in progress) and embraces current Java features – for example, it offers an option to use virtual threads for handling requests, tapping into Java’s Project Loom capabilities. The 7.0 GA fixed numerous bugs and made some notable changes: it allows disabling of Micronaut-based auto-configuration in Grails plugins when there are test coverage issues (acknowledging the hybrid use of Micronaut inside Grails), it improved the reproducibility of builds for Grails services, and temporarily removed the GORM for Neo4j integration until it can be updated for the new release. Under the hood, Grails 7 also updates to Hibernate 6 and Groovy 5, aligning with the latest Java and Jakarta EE standards. Equally significant from a community perspective, Grails graduated from Apache Incubator to a Top-Level Project in October – a journey that started with an open letter in 2024 citing dwindling corporate support. Now officially an ASF project, Grails has a renewed governance and contributor base. For developers, Grails 7.0 brings the familiar productivity of Grails (convention-over-configuration, GORM, etc.) but on a much more up-to-date stack, ensuring that Groovy and Grails remain viable for building web applications in the age of Java 25. [infoq.com] [infoq.com]
⚡ Quarkus 3.28 & 3.29 Updates: Red Hat’s Quarkus (“supersonic subatomic Java”) continued its rapid iteration cycle with a pair of releases in October. Early in the month, Quarkus 3.28.x saw a few bugfix micro-releases (3.28.1, 3.28.2, 3.28.3) to address issues and polish the major Quarkus 3.28.0 that had arrived in late September. These fixes included improvements in logging for OIDC clients (logging HTTP requests in debug mode for easier troubleshooting) and ensuring proper cleanup of HTTP server responses on exceptions. The more feature-focused update came with Quarkus 3.29.0.Final, released later in October, which introduced some notable enhancements. Quarkus 3.29 added support for using multiple caching providers at once – developers can now configure different cache backends (memory, distributed, etc.) simultaneously in a Quarkus app, which is useful for hybrid caching strategies. Another handy addition was support for the Debug Adapter Protocol (DAP) in Quarkus’s Qute templating engine dev console, making it easier to debug Qute templates using IDE tools. Quarkus 3.29 also bumped its baseline dependencies (ensuring compatibility with the latest Hibernate ORM, RESTEasy, etc.) and included numerous fixes as Java 25 adoption grows. With these updates, Quarkus remains a top choice for building native-optimized and cloud-ready Java apps, continually refining developer experience – from dev UI improvements to seamless hot-reload – as the Java platform evolves. Expect a 3.30 or 3.31 release next, likely aligning with any new CVE fixes or JDK changes, as Quarkus tends to follow both the Java release train and community feedback closely. [infoq.com] [infoq.com]
🤖 Micronaut 4.10.0 Advances (AI in Mind): The Micronaut framework (known for its ahead-of-time compilation and minimal footprint) released version 4.10.0 in October, signaling the project’s commitment to stay on the cutting edge for microservices and cloud apps. A key theme for Micronaut this release was AI and machine learning integration. Micronaut 4.10 debuted a brand-new module called Micronaut MCP (Model Context Protocol). MCP is an emerging standard (spearheaded by projects like Spring and Open Liberty) that allows applications to expose their capabilities in a machine-readable way for large language models (LLMs) to discover and invoke. By integrating MCP, Micronaut enables Java applications to more easily interact with AI agents – essentially bridging the gap between a running microservice and an external AI that wants to query or command it. Alongside the MCP module, Micronaut 4.10 updated its LangChain4j integration to version 1.5.0, bringing improvements to how Java apps can orchestrate LLM-driven workflows (LangChain4j is a Java library inspired by Python’s LangChain for chaining LLM calls with tools and memory). Another internal improvement in Micronaut 4.10 is the introduction of a new ReadBuffer abstraction to replace the older ByteBuffer interface for certain data processing tasks. This change, while low-level, can yield performance and maintainability benefits in how Micronaut handles I/O and binary data. Micronaut also upgraded various dependencies and made typical bug fixes. Overall, the 4.10 release keeps Micronaut’s core strong and adds experimental yet forward-looking features that acknowledge the rising importance of AI in enterprise Java applications. [infoq.com]
📦 Other Notable Library Updates: A number of other Java libraries and frameworks delivered releases in October, focusing on stability and incremental improvements:
NumberFormatException on certain Content-Length: null headers). Ktor continues to ensure that Kotlin’s evolution aligns with stable server development. [infoq.com]AgenticScope interface for better control over agent tools and allowed passing custom attributes into chat memory stores. These additions make it easier to manage conversational state and tool usage when integrating LLMs into Java apps (e.g., enabling certain memory or tool behaviors in specific contexts). [infoq.com]Together, these framework and library updates show a Java ecosystem that is both highly active and future-oriented. From cloud-native runtimes (Quarkus, Micronaut) to venerable web frameworks (Spring, Grails) and niche tools, almost every project is incorporating Java’s latest capabilities (records, virtual threads, new concurrency models) and preparing for a Java 25+ world. Security patches (as seen in Spring Security and REST Docs dropping old dependencies) and performance optimizations (Hazelcast, Micronaut) were a recurring theme, reflecting an emphasis on production readiness and efficiency.
Java 25 Gets Its First Updates: One month after its GA, Java 25 began its lifecycle as a long-term support release with the usual round of post-launch fixes. In October, Oracle delivered the Critical Patch Update (CPU) for Q4 2025, which included JDK 25.0.1 as well as updates for older LTS releases (JDK 21.0.9, 17.0.17, 11.0.29, and 8u471). These CPU releases address security vulnerabilities and critical bugs discovered since the previous quarterly update. Notably, this was Java 25’s first patch, and it resolved several security issues to ensure that early adopters of JDK 25 could proceed safely. Alongside Oracle, other OpenJDK distributors provided matching updates – for example, BellSoft released CPU and PSU (patch set) updates for its Liberica JDK, backporting fixes to even Java 6 and 7 in line with Oracle’s advisory. With over 687 fixes and backports merged across the various JDK versions, October’s patches underscore the Java platform’s strong focus on security and stability. For developers, upgrading to JDK 25.0.1 (or the corresponding build from your vendor) is highly recommended to keep applications secure. No major breakages were reported with JDK 25 in the wild – most users found the transition from Java 21 or 17 to be smooth, aside from a few small behavioral adjustments (the Inside Java blog highlighted one such change: the behavior of new File("") was made more consistent, as part of quality outreach). In short, Java 25 is proving to be a solid release, and with the first set of critical fixes applied, it’s on track to become the new workhorse LTS for the next few years. [infoq.com] [dev.java]
OpenJDK Begins Shaping JDK 26: Even as Java 25 enters adoption, OpenJDK development for Java 26 is well underway. During October, several proposed features for JDK 26 advanced in status, giving a preview of what’s coming in the March 2026 release. Among the JDK Enhancement Proposals gaining traction:
JEP 525: Structured Concurrency (Sixth Preview) was proposed-to-target for JDK 26. This will mark yet another refinement of structured concurrency, a feature that helps manage multiple threads as a single unit of work. The main change in the 6th preview is a new StructuredTaskScope.Joiner.onTimeout() method, which allows a result to be returned if a task times out. This tweak improves the ergonomics of handling timeouts when using structured task scopes. The structured concurrency API has been previewed in Java 19–25, and with each round it’s gotten closer to final; the JDK 26 preview suggests it’s nearly ready, making asynchronous operations in Java more reliable and easier to reason about. [infoq.com]
JEP 529: Vector API (Eleventh Incubator) was also moved to proposed-to-target for JDK 26. The Vector API allows developers to write vectorized computations in Java, which can be at runtime compiled to CPU SIMD instructions for significant performance gains in data processing (e.g. math, cryptography). JEP 529 indicates an 11th incubator version of this API with JDK 26, meaning the API is still not final but remains under active development. There are no major changes from the 10th incubator (in JDK 25), but it will continue to evolve, possibly awaiting Project Valhalla features (like primitive value types) before it can finalize. The commitment to yet another incubator round shows that while not GA, the Vector API is considered important for performance-critical Java code and will be kept up-to-date until all dependencies (like value types) are in place. [infoq.com]
JEP 516: AOT Object Caching for All GCs was proposed for JDK 26. This extends the work from JDK 24’s JEP 483 (Ahead-of-Time Class Loading & Linking) by making the ahead-of-time compiled object data usable with any garbage collector, including ZGC. In simpler terms, it improves startup and warm-up by caching certain objects so that any GC can quickly load them. This is part of the broader Project Leyden efforts to improve Java’s startup performance. October also saw an update from Project Leyden itself: an early prototype of Java with static runtime optimizations (based on JDK 26) is available as mentioned in August, and these AOT caching improvements dovetail with that work. For cloud and serverless scenarios, such enhancements could mean faster cold starts and less CPU overhead. [infoq.com] [manorrock.com]
JEP 500: Make Final Mean Final was proposed to target JDK 26. This one is less about new functionality and more about stronger integrity: it intends to disallow deep reflection hacks that mutate final fields (currently, frameworks can use setAccessible(true) to bypass final and change fields via reflection). JEP 500 is essentially preparing the ecosystem for a future where final truly means immutable after construction, enhancing security and clarity. If this goes through, some frameworks (or libraries like serialization frameworks) might need adjustments, but it’s targeted for the long term health of the platform. The review for JEP 500 (and 516 and 529) is ongoing and expected to conclude in early November. [infoq.com]
Additionally, JEP 530: Primitive Types in Patterns (Fourth Preview) moved to Candidate status in October, meaning we might see pattern matching over primitive types (like int and long in switch statements or instanceof) previewed again in JDK 26 with minor improvements. And although not a formal JEP change in October, there’s progress on Project Valhalla (value classes) and Project Amber features: for example, an Inside Java Newscast episode on Oct 31 discussed improvements in value class heap flattening (related to Valhalla’s JEP 401), suggesting that Java 26 or 27 could see some early pieces of Valhalla (like value object previews). [infoq.com] [dev.java]
On the tooling side of OpenJDK, October brought jtreg 8.1 (the testing harness for JDK) which improved test logging and Unix environment handling – a niche but important update for OpenJDK contributors ensuring the JDK’s own test suite is robust. And as usual, weekly JDK 26 early-access builds rolled out (build 19 in early October, up to build 22 by end of the month), each incorporating the latest bug fixes from the mainline. OpenJDK developers are encouraged to download these EA builds and report any issues, to flush out bugs early. [infoq.com] [infoq.com]
Looking Ahead: With these developments, Java 26 is starting to take shape: expect a strong focus on developer productivity and performance (structured concurrency, AOT, Valhalla previews) and on integrity/simplification (like final fields, and perhaps removal of legacy baggage such as the long-deprecated Applet API which is slated for JDK 26). For everyday developers, the October news around the platform means that Java 25 is safe to adopt (now that initial patches are out), and we can already peek into the enhancements coming in the next release. It’s a good time to be a Java developer – the platform is evolving carefully and continuously. [infoq.com]
Jakarta EE 12 Plans and New Specs: With Jakarta EE 11 released in mid-2025, the enterprise Java community has turned its attention to Jakarta EE 12. October brought clarity to some key pieces of EE 12:
The Jakarta EE Platform Project set a date of Dec 9, 2025 for Milestone 2 of Jakarta EE 12. By that milestone, the aim is to firm up the list of tasks and component specifications that will define EE 12. Many ideas are on the table (some specifications didn’t deliver everything in EE 11 and deferred items to EE 12), and in the next month or two those will be solidified. The Milestone 2 contents will build on Milestone 1 (the initial plan drafted earlier) and add any new proposals that the community deems important. [infoq.com]
A significant new specification in the works is Jakarta Query 1.0. In early October, the first milestone of Jakarta Query 1.0 was released. Jakarta Query’s goal is to modernize and unify how persistence queries are defined in Jakarta EE. It effectively combines the established JPQL (Jakarta Persistence Query Language) with ideas from the newer Jakarta Data specification (which had its own “JDQL”) into a single, coherent query language for the platform. The milestone unified the query language semantics and cleaned up the spec documentation. By mid-October, a ballot vote was held to include Jakarta Query in the Jakarta EE 12 platform and web profiles, and it received unanimous positive votes, indicating that Jakarta EE 12 will officially incorporate Jakarta Query. For enterprise developers, this means a more powerful and consistent querying capability baked into the standards – one that could span JPA and NoSQL data stores under a common syntax. [infoq.com]
Perhaps the most buzzworthy development: a proposal for Jakarta **Agentic AI** (often shortened as Jakarta AI) was submitted and entered creation review in October. This is a brand new initiative to define how Jakarta EE applications can interact with AI agents and services. Jakarta AI (if approved) would provide standard APIs or patterns for integrating Large Language Models, AI-driven “agents,” or machine learning workloads into enterprise Java apps. The idea garnered exceptional community interest – the Eclipse Foundation’s Jakarta EE committee saw a record number of community votes in favor of creating this spec, more than any prior Jakarta spec proposal. The creation review was set to conclude by November 5, and indications are that it would pass. While it’s early stages (nothing is implemented yet), the fact that Jakarta EE is exploring AI integration as a first-class concern is notable. It signals that enterprise Java is evolving to meet current trends, ensuring Java remains relevant for AI-powered applications in sectors like finance, healthcare, and beyond. [infoq.com]
Another area under discussion for EE 12 is reviving or updating older specs. One example floating around is whether an older Java EE spec like JSR 381 (Visual Recognition) or other AI/ML-related JSRs could be brought in under Jakarta’s umbrella, but for now Jakarta AI seems the likely path. There’s also talk of making Java SE 21 the baseline for EE 12 (EE 11 uses Java 17 as baseline with optional Java 21 features), which would allow EE 12 to leverage features like virtual threads more broadly.
EE 11 Adoption and Implementations: In the meantime, Jakarta EE 11 (released June 2025) is gradually finding its way into products:
Eclipse GlassFish 7 (the reference implementation) remains the only fully certified Jakarta EE 11 server as of October. But others are close behind. IBM Open Liberty has been issuing monthly betas that implement pieces of EE 11 and beyond. In October, Open Liberty 23.0.0.10 (and the 23.0.0.11 beta) added full support for Java 21 and some EE 11 features. More interestingly, Open Liberty’s October beta (25.0.0.11) introduced an early access feature for Model Context Protocol (MCP) server integration. This feature (technically mcpServer-1.0 in Liberty) is aligned with that cross-project MCP initiative mentioned earlier: it lets a running Java EE app describe its capabilities in a way that external AI agents can query. In practical terms, Liberty is experimenting with how a Java business application could register “services” that an AI (like ChatGPT or a custom LLM) can discover and call. This is groundbreaking in that it bakes AI connectivity into the app server runtime. It shows IBM’s commitment to blending enterprise Java with AI tooling, likely a prelude to Jakarta AI spec support in the future. [infoq.com]
Red Hat WildFly 28 (the latest WildFly as of mid-2025) supports Jakarta EE 10, and WildFly 27 had some Jakarta EE 11 features (as it was used as an EE 11 preview). In October there wasn’t a new WildFly major release – WildFly 28 remains current. However, WildFly is in the process of moving to the CommonHaus foundation (renaming some Jakarta packages to comply with trademarks, etc., as noted in previous months). We expect WildFly 29 or 30 to fully embrace EE 11 perhaps by early 2026. WildFly’s community, meanwhile, stayed active with incremental improvements and a focus on microprofile and cloud capabilities. [manorrock.com]
Payara Server (based on GlassFish) had an August 2025 update indicating plans for EE 11 compatibility. By October, Payara was still in alpha for a Jakarta EE 11 full-profile implementation. The Payara Community 6.2025.x releases continued monthly; they address security issues like the Grizzly vulnerability fix in August and likely some bug fixes in Oct. Payara is aiming for Jakarta EE 11 certification perhaps by end of year, which would give the community another production-ready EE 11 option.
Apache TomEE (which integrates Tomcat with EE APIs) is a bit behind, currently on Jakarta EE 9/10 level. There’s ongoing work for EE 10/11 support in TomEE 9.0, but no EE 11 TomEE release yet.
MicroProfile 6 (which aligns with Jakarta EE 10) had a minor update in October (MP 6.1 discussion started), and plans for MicroProfile 7 will likely coincide with Jakarta EE 11 or 12 timing, to incorporate things like Config 3.0, Fault Tolerance updates, etc., but details are still in early stages.
In summary, Enterprise Java is in a transitional phase: Jakarta EE 11 is out and implementations are catching up, while the community actively plans Jakarta EE 12 to ensure Java remains a top choice for enterprise development. The inclusion of features like Jakarta Query will improve developer productivity (making data access more uniform), and the bold step into Jakarta AI shows a willingness to expand Jakarta EE’s scope to new domains. It’s also worth noting that enterprise Java is now truly community-driven under the Eclipse Foundation, which is evident from the high engagement on proposals (the community voice is influencing decisions such as adding an AI spec). The coming months will likely bring more concrete updates on EE 12 specs (watch for announcements around EclipseCon or JakartaOne Livestream events), but October has set the direction: lighter, faster, and smarter (AI-enabled) enterprise Java is on its way.
October was a busy month not just for frameworks, but also for the tools that support Java developers in building, testing, and deploying software. Key updates include build tools, release automation, and even other JVM languages:
Gradle 9.2 Released: The Gradle team delivered Gradle v9.2.0 in October, following a release candidate cycle that ensured compatibility with Java 25. Gradle 9.2’s headline updates are on the infrastructure and quality-of-life side: it now supports running Gradle builds on Windows ARM64 machines, which is important as ARM-based hardware (like Apple M1/M2 and Windows on ARM laptops) becomes more common for developers. This eliminates a pain point for anyone using Windows on ARM, who previously had to rely on x86 emulation to run Gradle. In addition, Gradle 9.2 improves how custom software components are defined and published. It exposes a new SoftwareComponentFactory through the PublishingExtension, which plugin and library authors can use to better control the publishing of multi-component projects (for example, if a project builds several related artifacts that need to be published together, this is now easier and more formalized). The error and warning reporting in Gradle’s command-line interface was also refined – Gradle continues to tweak the developer experience so that build failures give actionable feedback. Under the hood, Gradle 9.2 of course includes dependency upgrades and full support for JDK 25, ensuring that teams can build Java 25 projects without issues. With Maven 4 still in alpha, Gradle remains the most cutting-edge build system for Java, and these 9.x series updates keep it competitive and up-to-date with platform changes. [infoq.com]
JReleaser 1.21.0: The JReleaser tool, which helps automate and simplify Java project releases (packaging binaries, publishing to Maven Central, announcing on social platforms, etc.), reached version 1.21.0. This release packed a few interesting new features:
signing.mode=COMMAND.
Beyond these, JReleaser continues to support a wide array of package formats (jars, native image, Docker images) and distribution channels. The 1.21 release shows the project’s responsiveness to developer needs (Reddit was likely added due to community request) and its embrace of new capabilities on platforms like GitHub. Automating release tasks might not be glamorous, but it’s a huge time-saver – with JReleaser’s continued evolution, Java devs can spend less time on the mechanics of publishing and more on coding. [infoq.com]Seed4J 2.1.0 (formerly JHipster Lite): The lightweight code generator JHipster Lite underwent a rebrand to Seed4J in late September, and in October we saw Seed4J 2.1.0 released. This tool helps bootstrap new applications with a modular approach (as opposed to the original JHipster, which is more monolithic). The 2.1.0 version brings it up-to-date with JDK 25 support out of the box, meaning generated projects can use the Java 25 runtime without hassle. It also introduces improvements in how it generates certain front-end components (it added Tailwind CSS for styling in the Angular templates) and health check types. The name change from JHipster Lite to Seed4J reflects an expanded mission to serve as a general “seed” for Java projects, not necessarily a slimmed JHipster. The team behind it even published an InfoQ article on version 2.0, indicating active development and community interest. For enterprise teams starting new projects, tools like Seed4J can provide well-structured starters that follow best practices (security config, Docker setup, CI workflows, etc.), now fully aligned with the newest Java versions. [infoq.com]
Kotlin and Scala Updates: Though Java is the centerpiece, October had news in other JVM languages:
@OperatorRename and enjoying the updated interactive shell with syntax highlighting. [manorrock.com]Testing and CI/CD: In testing frameworks, JUnit 5.10 (released just before October) and early builds of JUnit 6 were being tried out by projects like Spring REST Docs. Selenium 4.12 came in October with support for new browser versions and Grid improvements. On the CI front, GitHub Actions and Jenkins didn’t have specific Java-related releases, but many teams updated their pipelines to run on JDK 25 once it became available in actions and container images. [infoq.com]
All these tool updates, while not as flashy as a framework release, contribute to a healthy Java developer experience. They ensure that as Java evolves, the surrounding ecosystem (build tools, CI tools, languages on the JVM, etc.) evolves in tandem. Developers can confidently adopt Java 25 knowing Gradle or Maven can build it, their release process can handle it, and their favorite language or library is compatible. October’s message in the tooling space was one of steady modernization – clearing roadblocks (Gradle on ARM), expanding capabilities (JReleaser, Seed4J), and maintaining compatibility with Java’s latest.
October 2025 was vibrant in the Java community, with major conferences, significant announcements, and continued enthusiasm around Java’s future. Here are some highlights:
Oracle AI World 2025 – Java in the Spotlight: Oracle’s marquee event this fall was Oracle AI World (Oct 17–19, 2025 in Las Vegas), which for the first time included a dedicated Java track. This reflects Oracle’s effort to position Java within the AI and cloud computing conversation. A highlight of the Java track was a presentation by Georges Saab (Senior VP of Development for the Java Platform at Oracle) titled “Java 25: Advancing AI and Cloud”. In this session – also featured on Oracle’s online coverage – Saab unveiled how Java 25’s new features benefit AI and cloud workloads. For example, he discussed using virtual threads to handle the massive concurrency of AI data processing, and how record patterns and sealed classes can help model AI domain data more safely. He also touched on Java’s performance improvements (like faster startup from Project Leyden’s early work, and GC optimizations) as critical for cloud deployments that scale on demand. The takeaway for attendees was that modern Java is ready for AI: with its strong security, mature tooling, and new enhancements, Java can be a robust choice for AI services when paired with native libraries or cloud AI platforms. Outside of the Java track, AI World’s keynotes (e.g. Oracle’s “Autonomous AI” announcements) painted a picture in which Java-based applications will integrate AI services via Oracle’s cloud – so Java developers are very much part of Oracle’s AI strategy. The conference also teased a new Oracle Cloud feature where the Oracle Java runtime will have built-in connectors to Oracle’s AI services, making it easier to call AI APIs from Java code (something to watch in upcoming updates). [dev.java]
JavaOne 2026 – Revival Announced: Oracle had merged JavaOne into Oracle Code One/CloudWorld for a few years, but as noted in September, JavaOne is coming back as a standalone conference in 2026. In October, Oracle officially opened the Call for Papers (CFP) for JavaOne 2026 and confirmed the event dates: March 17–19, 2026 in Redwood Shores, California. This will coincide with the Java 26 release timeframe, making it a perfect venue to discuss Java 26 features and real-world Java 25 adoption stories. The return of JavaOne has generated a lot of excitement in the community – many see it as a sign of Oracle renewing focus on Java developers. The CFP being live means that Java champions, experts, and enthusiasts can submit talks on everything from core JVM advancements to library case studies. Given that 2025 marks Java’s 30th anniversary, the 2026 JavaOne is expected to be special – likely celebrating Java’s history and future. Oracle’s developer relations teams (as evidenced by Inside.java newsletters) are heavily promoting this CFP to ensure diverse and rich content. By end of October, folks on social media were already discussing panel ideas and hoping for the kind of hallway conversations that only an in-person JavaOne can bring. For those who fondly remember JavaOne from the Sun era, this news is a welcome blast from the past and a hopeful sign for Java’s community engagement.
JCon, Joker, JFall – Developer Conferences: Several community-driven Java conferences took place in October:
Community Content and Discussions: The Java community produces a vast stream of blogs, videos, and podcasts, and October was no exception. A few trends in community content:
ScopedValues API versus ThreadLocal, and YouTube videos like “Handling Breaking Security Changes in Java 25” covering the removal of certain outdated cryptography algorithms. The Inside Java Newscast on YouTube had an episode where Nicolai Parlog answered community questions about Java 25’s design decisions. And Oracle’s Java team published an Inside.java article on JDK 25 GC changes for G1/Parallel/Serial GCs, which is gold for JVM tuning enthusiasts. [blog.jetbrains.com]Industry Moves: There weren’t huge vendor shake-ups in October, but a few noteworthy items:
In sum, the Java community in October 2025 showed a mix of enthusiasm for new tech (Java 25, AI, Loom, Valhalla) and practical focus (patching vulnerabilities, planning upgrades). The return of in-person events like JavaOne and the continued success of community conferences demonstrate a robust, connected community. Java’s ecosystem doesn’t sit still: as soon as Java 25 was out, folks are testing its limits; as JDK 26 features surface, discussions spark on mailing lists and forums. And importantly, there’s a sense of inclusiveness in the air – from Jakarta EE inviting community votes on new specs, to the global spread of Java user gatherings, it’s clear that the evolution of Java is truly a collective effort.
Wrapping up October 2025, we’ve seen Java solidify its latest release and simultaneously push into new domains like AI and cloud with vigor. The foundations (JDK, Jakarta EE) are strong and moving forward, the frameworks are innovating, and the community is energized. If this momentum continues, by the time we reconvene for the next Pulse on Java, we’ll likely be celebrating even more: perhaps Spring 7.0 GA, early JDK 27 drafts, or new breakthroughs in Java performance. One thing is certain: Java’s ecosystem, at 30 years old, is far from slowing down – if anything, it’s entering a new golden age of innovation and community-driven development. Stay tuned, and happy coding! [manorrock.com], [blog.jetbrains.com]