The Java Ecosystem Thrives with Project Valhalla’s Value Objects Reintroduction, WildFly 41 GA, and Oracle’s New AI Agent Studio

The week of July 13th, 2026, has proven to be a particularly dynamic period for the Java ecosystem, showcasing continuous innovation across foundational elements, enterprise platforms, and emerging technologies like Artificial Intelligence. Developers witnessed significant advancements, from the reintroduction of critical language enhancements under Project Valhalla to major General Availability (GA) releases of leading application servers and groundbreaking tools for AI integration. This confluence of updates underscores Java’s enduring relevance and its strategic evolution to meet the demands of modern software development, spanning cloud-native architectures, high-performance computing, and intelligent systems.

Project Valhalla: Reshaping Java’s Core with Value Objects

A pivotal announcement this week comes from the OpenJDK project, specifically Project Valhalla, with the reintroduction of JEP 401, "Value Objects (Preview)," to Candidate status. This marks a significant milestone in a long-running initiative aimed at fundamentally rethinking how Java handles data and objects to achieve unprecedented levels of performance and memory efficiency. Originally envisioned as "Object Classes and Values (Preview)" and first drafted in August 2020 as JEP Draft 8251554, JEP 401 proposes to enhance the Java language with value objects.

The concept of value objects is designed to address some of the performance limitations inherent in Java’s traditional object model, particularly concerning memory layout and garbage collection overhead. Defined as objects that contain only final fields, do not possess identity, and are solely distinguished by the values of their respective fields, value objects offer a paradigm shift. Unlike traditional Java objects, which reside on the heap and have unique identities, value objects are intended to be more like C-style structs or primitives, allowing for flatter memory layouts and improved cache locality. This change is poised to reduce the burden on the garbage collector and enable HotSpot to apply more aggressive optimizations, leading to substantial performance gains for data-intensive applications.

Project Valhalla, initiated several years ago, has been a cornerstone of Java’s long-term evolution, seeking to bridge the semantic gap between Java’s object model and the underlying hardware. By introducing concepts like value types (of which value objects are a critical component), the project aims to allow Java to better utilize modern CPU architectures and memory hierarchies. The re-introduction of JEP 401 to Candidate status indicates a growing maturity in its specification and a clearer path towards its eventual inclusion as a preview feature in a future JDK release. This iterative process, involving extensive community feedback and rigorous testing, is characteristic of OpenJDK’s commitment to robust and well-vetted language enhancements. Developers eagerly anticipate the practical implications, which could include writing more performant code without resorting to complex low-level optimizations, ultimately making Java an even more compelling choice for demanding workloads.

Continuous Evolution: JDK 27 and JDK 28 Early-Access Builds

The rapid pace of Java development was further highlighted by the ongoing release of early-access builds for future JDK versions. This past week saw the availability of Build 31 of the JDK 27 early-access builds and Build 7 of the JDK 28 early-access builds. These regular updates are a critical part of the OpenJDK development model, allowing developers and integrators to preview upcoming features, test compatibility, and provide crucial feedback long before official releases.

Each build typically incorporates a series of bug fixes and minor enhancements, ensuring that the development branches remain stable and progressive. The updates from Build 30 to Build 31 for JDK 27, and from Build 6 to Build 7 for JDK 28, reflect a continuous cycle of refinement. This proactive approach to development minimizes the risk of major regressions and allows the community to contribute to the robustness and quality of future Java releases. These early-access builds are instrumental in maintaining Java’s reputation for stability and security, preparing the ground for the next long-term support (LTS) releases and feature releases.

Enterprise Java Strengthens its Cloud-Native Stance: WildFly 41 and Open Liberty 26.0.0.7

The enterprise Java landscape saw significant advancements with the General Availability (GA) releases of two prominent application servers: WildFly 41 and Open Liberty 26.0.0.7. These updates underscore the continuous effort to adapt traditional Java EE/Jakarta EE platforms for modern cloud-native and microservices architectures, emphasizing efficiency, security, and developer experience.

WildFly 41: Enhanced Cloud-Native Capabilities and Modern JDK Support

The release of WildFly 41, the open-source application server maintained by Red Hat, brings a suite of bug fixes, dependency upgrades, and new features designed to bolster its appeal in cloud environments. A standout feature is the enhanced support for bootable JARs within the wildfly-cloud-galleon-pack and the wildfly-maven-plugin feature packs. Bootable JARs are transformative for cloud-native deployments, allowing an entire application server and application to be packaged into a single, executable JAR file. This simplifies deployment, reduces startup times, and aligns perfectly with the immutable infrastructure and containerization paradigms prevalent in modern cloud platforms like Kubernetes. This feature significantly lowers the barrier to entry for deploying WildFly applications in highly dynamic and scalable environments.

Furthermore, WildFly 41 introduces a JDK 25 edition of its container, S2I builder, and runtime images, which replaces the earlier JDK 17 edition. This continuous upgrade path ensures that WildFly users can leverage the latest performance improvements, security enhancements, and language features provided by newer Java versions. The rapid adoption of recent JDKs demonstrates WildFly’s commitment to staying at the forefront of Java technology. The promotion of several features from preview to community and default stability levels also signifies their maturity and readiness for production use, providing greater confidence to enterprise users. This progression through stability levels is a testament to the rigorous testing and community feedback process that ensures the reliability of WildFly’s offerings.

Open Liberty 26.0.0.7: Fortifying Security and MicroProfile Compliance

IBM’s Open Liberty, a lightweight, open-source application server compatible with Jakarta EE and MicroProfile specifications, also reached GA with version 26.0.0.7. This release focuses heavily on security enhancements and improved developer control. A critical new feature is the default tracking of logged-out Single Sign-On (SSO) cookies, preventing their re-use after a user logs out. This directly addresses a potential security vulnerability by mitigating replay attacks and reinforcing session integrity, a crucial aspect for enterprise applications handling sensitive data.

The release also introduces the ability to disable the /health endpoints from MicroProfile Health 4.0 when a file-based health check mechanism is in use. This flexibility allows developers to tailor their health monitoring strategies to specific deployment needs or security policies, providing greater control over exposed endpoints in production environments. MicroProfile Health is a vital standard for cloud-native applications, enabling external systems (like Kubernetes orchestrators) to determine the health and readiness of deployed services.

Crucially, Open Liberty 26.0.0.7 addresses eight Common Vulnerabilities and Exposures (CVEs). These fixes tackle serious security concerns, including denial-of-service attacks, HTTP request smuggling, and server-side request forgery. Denial-of-service attacks can cripple application availability, while HTTP request smuggling and server-side request forgery can lead to unauthorized access, data exfiltration, or system compromise. The swift and comprehensive resolution of these vulnerabilities underscores the platform’s commitment to providing a secure foundation for enterprise applications, which is paramount for mission-critical systems.

Collectively, the updates to WildFly and Open Liberty illustrate a mature and responsive enterprise Java ecosystem. These platforms are not merely maintaining their status but are actively evolving to provide robust, secure, and performant solutions tailored for the complexities of modern cloud deployments, ensuring Java’s continued dominance in enterprise software.

Accelerating Performance: TornadoVM 5.1.0

For developers pushing the boundaries of Java in high-performance computing (HPC) and artificial intelligence, TornadoVM 5.1.0 delivers significant advancements. TornadoVM is a powerful plugin for OpenJDK that allows developers to execute Java applications on heterogeneous hardware, including GPUs, FPGAs, and other accelerators, without requiring extensive code rewrites in native languages like CUDA or OpenCL. Its goal is to bring the productivity of Java to performance-critical domains.

Version 5.1.0 introduces support for E4M3 and E5M2 eight-bit floating-point storage in its CUDA backend. This is particularly relevant for machine learning workloads, where reducing the precision of floating-point numbers can drastically cut down memory usage and accelerate computations on specialized AI hardware, often with minimal impact on model accuracy. The addition of an opt-in staged host-to-device transfer path for both PTX and CUDA backends further optimizes data movement between the CPU and accelerators, a perennial bottleneck in HPC. Efficient data transfer is critical for maximizing the utilization of high-speed parallel processors.

Furthermore, a notable performance improvement has been made within the withIntraPlanConcurrency() method, defined in the TornadoExecutionPlan class. This optimization reduces the general per-operation and per-join bookkeeping cost for all intra-plan concurrency plans, leading to more efficient execution of parallel tasks. These enhancements collectively broaden Java’s reach into scientific computing, data analytics, and machine learning, offering Java developers competitive performance with the ease of use of the JVM.

Server-Side Refinements: Apache TomEE 10.2.0

Apache TomEE, a lightweight, enterprise-grade Java EE/Jakarta EE application server built upon Apache Tomcat, released version 10.2.0. This update focuses on maintaining stability, enhancing security, and improving developer experience through dependency upgrades and targeted bug fixes. Keeping dependencies current is crucial for patching known vulnerabilities and leveraging performance improvements in underlying libraries.

The release addresses several notable bug fixes, including a critical issue where the sslTruststorePassword parameter from the HttpConnection inner class (within HttpConnectionFactory) was not being properly masked or stripped during logging. This oversight could expose sensitive credentials in log files, posing a significant security risk. Its resolution enhances the overall security posture of applications deployed on TomEE. Another important fix involves an AuthenticationException thrown from within the authenticate() method in the JNDIContext class, which previously lost the cause thrown by the RemoteException. Preserving the original exception cause is vital for proper error diagnosis and debugging, improving developer productivity and system maintainability. These targeted improvements ensure TomEE remains a reliable and secure choice for deploying Jakarta EE applications.

Kubernetes Orchestration with Java: Java Operator SDK 5.5.0

As Kubernetes continues to dominate container orchestration, the ability to manage complex applications through custom controllers (Operators) is becoming increasingly important. The Java Operator SDK, a framework designed to simplify the creation of Kubernetes Operators in Java, released version 5.5.0 with significant enhancements for resource management and flexibility.

The new release introduces a complete and consistent family of update/patch/create methods within the ResourceOperations class. These methods now robustly support both RFC 6902 (JavaScript Object Notation (JSON) Patch) and RFC 7386 (JSON Merge Patch) specifications. JSON Patch allows for highly granular, efficient updates to Kubernetes resources by describing specific changes (add, remove, replace, move, copy, test), while JSON Merge Patch provides a simpler, less granular approach. Full support for these standards empowers Java Operator developers to implement more sophisticated and efficient resource reconciliation logic, minimizing unnecessary updates and reducing API server load.

Additionally, a new Matcher interface has been introduced, allowing developers to plug custom matching strategies into the overloaded matchAndFilter() method defined in the Options class. This flexibility is invaluable for Operators that need to compare resources based on complex business logic or specific criteria beyond simple equality checks. Custom matchers enable more precise control over when an Operator decides a resource needs to be updated or recreated, enhancing the intelligence and adaptability of Java-based Kubernetes Operators. These features solidify Java Operator SDK’s position as a leading tool for building robust and enterprise-grade Kubernetes Operators, further embedding Java within the cloud-native infrastructure ecosystem.

Java Enters the AI Agent Arena: LangChain4j 1.18.0

The burgeoning field of Artificial Intelligence, particularly Large Language Models (LLMs) and agentic systems, is rapidly integrating with the Java ecosystem. LangChain4j, a Java port and adaptation of the popular LangChain framework, reached its formal release with version 1.18.0 (concurrently with its twenty-eighth beta release), bringing powerful AI capabilities to Java developers.

A highlight of this release is the introduction of a new Belief-Desire-Intention (BDI) agentic pattern. BDI is a cognitive architecture that provides a structured method to formalize psychological concepts for software and robotic systems. It enables the creation of more sophisticated, goal-oriented AI agents that can reason about their beliefs, pursue desires, and execute intentions in dynamic environments. For Java developers, this means building more robust and autonomous AI applications, moving beyond simple prompt-response interactions to complex, multi-step agentic workflows.

Furthermore, LangChain4j 1.18.0 adds a new TextToSpeechModel interface to support the OpenAI Text-to-Speech API. This integration allows Java applications to generate natural-sounding speech from text, opening up possibilities for voice-enabled user interfaces, accessibility features, and interactive AI agents. The release also includes a new MistralAiBatchChatModel class, providing support for the Mistral Batch API. Mistral AI is a significant player in the LLM space, and batch processing capabilities are crucial for optimizing costs and throughput in production AI systems. By integrating with leading AI platforms like OpenAI and Mistral AI and offering advanced agentic patterns, LangChain4j firmly positions Java as a robust platform for developing cutting-edge AI-powered applications, especially within enterprise contexts where reliability and integration are key.

Modern Framework Updates: Micronaut 5.0.5 and Quarkus Shim

Two prominent modern Java frameworks, Micronaut and Quarkus, also saw important developments this week, reflecting their continuous efforts to provide efficient and developer-friendly platforms for microservices and cloud-native applications.

Micronaut 5.0.5: Maintaining Stability and Module Enhancements

The Micronaut Foundation released version 5.0.5 of the Micronaut Framework, built upon Micronaut Core 5.0.6. This is a maintenance release, critical for ensuring the stability and reliability of the framework’s ecosystem. Micronaut is known for its compile-time dependency injection and AOT (ahead-of-time) compilation, which result in fast startup times and low memory footprints, making it ideal for microservices and serverless functions.

The 5.0.5 release includes patch updates to several key modules, including Micronaut AWS, Micronaut gRPC, Micronaut Oracle Cloud, and Micronaut Logging. These module-specific updates ensure that integrations with major cloud providers and essential services remain robust, secure, and compatible with the latest underlying technologies. Such regular maintenance releases are vital for enterprise users who rely on the framework for long-term support and stability, ensuring their applications remain performant and secure.

Quarkus Shim: Advanced Build-Time Customization

The Quarkus team introduced a fascinating new experimental extension called Quarkus Shim. Quarkus, often dubbed "Kubernetes Native Java," distinguishes itself by performing extensive optimizations during its build phase, known as "augmentation." This process transforms application code and dependencies to be highly efficient at runtime, particularly for native executables generated with GraalVM.

Quarkus Shim leverages this augmentation phase to allow developers to add, wrap, or replace behavior in a Java class during a Quarkus build. The core innovation lies in its approach: "The change happens during augmentation. There is no Java agent and no runtime instrumentation. The transformed class works in JVM mode, dev mode, and native executables." This capability offers unprecedented levels of customization and optimization. Developers can, for example, inject custom logic into third-party libraries without modifying their source code, or optimize critical paths by replacing standard implementations with highly specialized ones, all at build time. This "shim" approach avoids the performance overhead and compatibility issues often associated with traditional Java agents or runtime bytecode manipulation. Built with Quarkus 3.37.3, this experimental extension is a testament to Quarkus’s innovative approach to making Java more performant and adaptable in demanding cloud-native environments.

Oracle’s Strategic Push into Enterprise AI: AI Agent Studio for Fusion Applications

Oracle made a significant announcement with the introduction of a new AI-native builder experience for Oracle AI Agent Studio for Fusion Applications. This move highlights Oracle’s strategic commitment to embedding advanced artificial intelligence directly into its enterprise application suite, empowering customers to leverage AI for business process automation and intelligence.

The AI Agent Studio allows customers to create and natively run "Fusion Agentic Applications" directly within Oracle Fusion Cloud Applications. This means that businesses can design and deploy intelligent agents that interact with their existing Oracle Fusion data and processes, automating tasks, providing insights, and enhancing decision-making. The studio provides a versatile development environment that integrates "no-code, low-code, and pro-code development into one Fusion-native framework." This inclusive approach caters to a broad spectrum of users, from business analysts who can configure agents with minimal coding to professional developers who can build complex, custom AI solutions.

By offering an AI-native builder experience, Oracle is positioning its Fusion Cloud Applications as a highly extensible platform where AI agents are not merely add-ons but deeply integrated components of business operations. This can lead to increased efficiency, improved customer experiences, and new opportunities for innovation across various industries. It is important to note that both AI Agent Studio and Fusion Cloud Applications are offered as subscription services, reflecting Oracle’s cloud-centric business model. This strategic integration of AI agents within a comprehensive enterprise application suite underscores a major trend in business software: moving beyond simple automation to intelligent, autonomous systems that drive business value.

Conclusion: A Vibrant and Evolving Java Landscape

The Java roundup for July 13th, 2026, paints a vivid picture of a technology ecosystem that is not only mature and stable but also intensely innovative and rapidly adapting to new paradigms. From the foundational language enhancements promised by Project Valhalla’s Value Objects to the enterprise-grade stability and cloud-native features of WildFly and Open Liberty, Java continues to fortify its core strengths. Concurrently, the advancements in specialized computing with TornadoVM, the robust Kubernetes integration via Java Operator SDK, and the significant strides in AI application development with LangChain4j demonstrate Java’s expansion into cutting-edge domains. Frameworks like Micronaut and Quarkus continue to push the boundaries of performance and developer experience, while Oracle’s AI Agent Studio showcases the deep integration of AI into enterprise applications. This week’s news collectively reaffirms Java’s position as a versatile, powerful, and future-proof platform for developers worldwide, capable of addressing the most complex challenges across diverse technological landscapes.