Java Ecosystem Sees Significant Advancements with Value Objects Reintroduction, Major Releases Across Application Servers, and AI Integration

The Java development landscape experienced a week of pivotal updates and innovations leading up to July 13th, 2026, highlighted by the reintroduction of JEP 401, Value Objects (Preview), under the ambitious Project Valhalla. This significant move by OpenJDK signals a crucial step towards modernizing the Java object model, promising substantial performance and memory efficiency gains. Concurrently, the ecosystem witnessed the General Availability (GA) release of WildFly 41, bringing enhanced cloud-native capabilities and updated JDK support, alongside the July 2026 edition of Open Liberty 26.0.0.7, which delivered critical security enhancements and new features for MicroProfile Health. Several specialized frameworks and tools also saw important point releases, including TornadoVM, Apache TomEE, Java Operator SDK, and LangChain4j, each contributing to their respective domains from high-performance computing to AI-driven application development. The Micronaut Framework issued a maintenance release, while Quarkus introduced an experimental extension, Quarkus Shim, for novel build-time class transformations. Rounding out the week’s notable announcements, Oracle unveiled a new AI Agent Studio for Fusion Applications, marking a strategic move to embed advanced AI capabilities directly into its enterprise software suite. These developments collectively underscore Java’s ongoing evolution, adaptability, and enduring relevance across diverse technological frontiers, from core language enhancements to cutting-edge AI and cloud-native deployments.

OpenJDK Progresses with Value Objects (Preview) Under Project Valhalla

A major highlight in the OpenJDK sphere this week was the reintroduction of JEP 401, "Value Objects (Preview)," to Candidate status. This proposal, a cornerstone of Project Valhalla, signifies a long-anticipated evolution in how Java handles data and objects. First drafted as JEP Draft 8251554 in August 2020, its return to candidate status, following previous iterations and extensive research, marks a crucial step toward its eventual integration into the Java language.

Project Valhalla itself is one of OpenJDK’s most ambitious undertakings, aiming to fundamentally rethink the Java Virtual Machine (JVM) and language to enable more efficient memory layouts and better performance. At its core, Valhalla seeks to bridge the semantic gap between Java’s primitive types (like int, long) and object types, allowing "objects that are not identity-sensitive." Value Objects are a key component of this vision. Unlike traditional Java objects, which possess an identity (meaning two objects with identical field values are still distinct if they are different instances in memory), value objects are solely defined by the values of their fields. This "identity-agnostic" nature, combined with the requirement that they only contain final fields, means they are immutable and behave much like primitives in terms of equality and memory representation.

The implications of Value Objects are profound. By allowing objects to be stored inline rather than always on the heap with separate pointers, they promise significant reductions in memory footprint and improved cache locality. This can lead to substantial performance gains, especially in data-intensive applications, by minimizing garbage collection overhead and enhancing CPU cache utilization. For developers, this translates to the ability to model data more naturally and efficiently, without sacrificing the safety and expressiveness of Java. For instance, complex numbers, geometric points, or currency amounts could be represented as value objects, behaving like primitive types while retaining object-oriented semantics. The journey to fully integrate Value Objects has been complex, involving deep changes to the JVM and language specification, but the community reaction has largely been one of anticipation, with developers eagerly awaiting the performance boosts and simplified data modeling that this feature promises.

JDK Early-Access Builds Advance: JDK 27 and JDK 28

The continuous development cycle of Java was evident with the release of new early-access builds for both JDK 27 and JDK 28. Build 31 of the JDK 27 early-access builds and Build 7 of the JDK 28 early-access builds were made available, each featuring updates and crucial bug fixes.

Early-access builds are a vital part of OpenJDK’s development methodology, providing a transparent and collaborative platform for the community to engage with upcoming Java versions. These builds allow developers, framework maintainers, and tool vendors to test their applications against future JDK releases, identify potential issues, and provide feedback long before the official General Availability. This proactive approach helps stabilize the platform, ensuring a smoother transition for the broader Java ecosystem upon release. The regular cadence of these builds, typically released weekly, reflects the ongoing commitment to iterative improvement and rigorous testing.

For JDK 27, Build 31 included a series of updates from Build 30, addressing various issues identified during the development process. Similarly, JDK 28’s Build 7 incorporated fixes from Build 6. While specific features are often stabilized and detailed closer to a GA release, these early builds are critical for catching regressions, optimizing performance, and ensuring compatibility across different components of the JDK. The release notes accompanying these builds serve as an essential resource for developers monitoring the progress, detailing the specific bug resolutions and minor enhancements integrated into each iteration. This transparent development model is a cornerstone of Java’s strength, fostering a robust and resilient platform through community involvement and continuous refinement.

WildFly 41 Achieves General Availability with Cloud-Native Enhancements

The popular open-source application server, WildFly, reached a significant milestone with the General Availability release of version 41. WildFly, historically known as JBoss AS, is a lightweight and modular application server that provides a robust implementation of the Jakarta EE specifications, making it a cornerstone for enterprise Java applications. This release focuses heavily on enhancing its capabilities for modern cloud-native deployments, alongside routine bug fixes and dependency upgrades.

One of the standout features in WildFly 41 is the significant improvement to bootable JARs, now integrated into both the wildfly-cloud-galleon-pack and the wildfly-maven-plugin feature packs. Bootable JARs streamline the packaging and deployment of WildFly applications, allowing developers to create self-contained executable JARs that include the application server itself. This approach is highly advantageous in microservices architectures and containerized environments, as it simplifies deployment, reduces startup times, and enables easier integration with CI/CD pipelines. This makes WildFly an even more compelling choice for developers building applications destined for cloud platforms like Kubernetes.

Furthermore, WildFly 41 introduces a JDK 25 edition of its container, S2I builder, and runtime images, replacing the previous JDK 17 edition. This update ensures that WildFly users can leverage the latest performance improvements, security enhancements, and language features provided by newer Java versions. Keeping pace with JDK releases is crucial for application servers to remain competitive and provide optimal environments for modern Java applications. The transition to JDK 25 underscores WildFly’s commitment to staying at the forefront of Java technology.

Another notable aspect of this release is the promotion of several features from preview to community and default stability levels. WildFly employs a clear feature stability model, which helps users understand the maturity and support level of different functionalities. Moving features to higher stability levels indicates that they have undergone thorough testing, received community feedback, and are deemed ready for broader adoption, providing greater confidence for enterprise deployments. This structured approach to feature development and promotion reflects a mature and reliable ecosystem for enterprise Java development, further cementing WildFly’s position as a leading Jakarta EE implementation.

Open Liberty 26.0.0.7 Enhances Security and MicroProfile Integration

IBM’s Open Liberty, a lightweight and modular application server renowned for its fast startup times and cloud-native capabilities, released version 26.0.0.7. This General Availability release emphasizes security and operational flexibility, crucial aspects for modern enterprise applications. Open Liberty, a key player in the Jakarta EE and MicroProfile ecosystems, continues to evolve with a strong focus on developer experience and production readiness.

A significant aspect of this release is its comprehensive approach to security. Open Liberty 26.0.0.7 addresses eight critical CVEs (Common Vulnerabilities and Exposures), mitigating risks such as denial-of-service attacks, HTTP request smuggling, and server-side request forgery. Denial-of-service vulnerabilities can render applications unavailable to legitimate users, while HTTP request smuggling allows attackers to bypass security controls and potentially access sensitive data. Server-side request forgery (SSRF) enables an attacker to induce the server-side application to make HTTP requests to an arbitrary domain, which can lead to data leakage or unauthorized actions. By promptly addressing these vulnerabilities, Open Liberty reinforces its commitment to providing a secure runtime environment, a paramount concern for any enterprise application.

Beyond vulnerability fixes, the release introduces new security features, including the default tracking of logged-out Single Sign-On (SSO) cookies. This enhancement prevents these cookies from being replayed after a user has logged out, effectively thwarting potential session hijacking attempts and improving overall authentication security. This proactive measure significantly reduces the window of opportunity for attackers to exploit stale or compromised session tokens.

Furthermore, Open Liberty 26.0.0.7 provides enhanced flexibility for MicroProfile Health 4.0 users. Developers now have the ability to disable the /health endpoints when utilizing a file-based health check mechanism. MicroProfile Health is a crucial component for cloud-native applications, allowing orchestrators like Kubernetes to determine the health and readiness of services. The option to disable these endpoints provides greater control over exposed interfaces, which can be beneficial in environments with specific security policies or when health checks are managed through alternative means, ensuring that only necessary endpoints are accessible. This blend of robust security patching and configurable operational features makes Open Liberty 26.0.0.7 a compelling update for developers prioritizing secure and adaptable cloud-native Java deployments.

TornadoVM 5.1.0 Accelerates High-Performance Computing in Java

TornadoVM, a cutting-edge platform for high-performance computing (HPC) in Java, released version 5.1.0, bringing a suite of enhancements aimed at further accelerating heterogeneous computing workloads. TornadoVM empowers Java developers to harness the power of GPUs and FPGAs directly from Java code, making it a critical tool for domains like scientific computing, machine learning, and financial modeling where raw performance is paramount.

This release introduces crucial support for E4M3 and E5M2 eight-bit floating-point storage in the CUDA backend. These compact floating-point formats are particularly significant for machine learning and deep learning applications, as they offer a balance between precision and memory efficiency. By reducing the memory footprint of data, these formats enable larger models to fit into GPU memory and accelerate computations, especially during inference phases where precision requirements can be more relaxed. This enhancement positions TornadoVM as an even more potent tool for AI/ML practitioners working within the Java ecosystem.

Another notable feature is the addition of an opt-in staged host-to-device transfer path for both PTX and CUDA backends. Data transfer between the host CPU and accelerator devices (like GPUs) is often a bottleneck in heterogeneous computing. Staged transfers optimize this process by allowing data to be moved in chunks or overlapping computation with communication, thereby reducing latency and improving overall throughput. This fine-grained control over data movement is essential for maximizing the utilization of high-performance accelerators.

Furthermore, TornadoVM 5.1.0 delivers a significant performance improvement within the withIntraPlanConcurrency() method, defined in the TornadoExecutionPlan class. This method is central to managing parallel execution plans within TornadoVM. The enhancement specifically reduces the general per-operation and per-join bookkeeping cost for all intra-plan concurrency plans. This optimization means that applications leveraging TornadoVM’s parallel execution capabilities will experience lower overheads, leading to faster execution times and more efficient resource utilization. These collective improvements in TornadoVM 5.1.0 underscore its continuous evolution as a vital platform for pushing the boundaries of Java’s performance in computationally intensive tasks.

Apache TomEE 10.2.0 Focuses on Stability and Security

Apache TomEE, a lightweight and flexible application server that combines Apache Tomcat with Apache OpenEJB, released version 10.2.0. As a certified Jakarta EE Web Profile implementation, TomEE provides a robust environment for developing and deploying enterprise Java applications, emphasizing ease of use and tight integration with Apache projects. This release primarily focuses on dependency upgrades and critical bug fixes, reinforcing its commitment to stability and security.

One of the key resolutions in TomEE 10.2.0 addresses a significant security oversight: the sslTruststorePassword parameter from the HttpConnection inner class was not being masked or stripped during logging. In production environments, logging sensitive information like truststore passwords poses a severe security risk, as it could expose credentials to unauthorized individuals or systems. Rectifying this issue ensures that such sensitive data is properly protected, aligning TomEE with best practices for secure application logging and significantly enhancing its security posture.

Another important bug fix in this release pertains to an AuthenticationException thrown from within the authenticate() method of the JNDIContext class. Previously, this exception would lose the original cause thrown by a RemoteException, making debugging and proper error handling considerably more challenging. By preserving the root cause, developers can now more effectively diagnose and resolve authentication failures, leading to improved application resilience and a better developer experience. This seemingly minor fix has a substantial impact on the maintainability and troubleshooting of TomEE-based applications.

The dependency upgrades included in TomEE 10.2.0 are also crucial. Keeping dependencies updated is vital for addressing known security vulnerabilities in third-party libraries, ensuring compatibility with newer Java versions, and leveraging performance improvements. This continuous effort to update underlying components demonstrates Apache TomEE’s dedication to providing a secure, high-performing, and up-to-date platform for Jakarta EE developers. The release notes provide comprehensive details on all the bug fixes and dependency updates, allowing users to understand the full scope of improvements in this latest version.

Java Operator SDK 5.5.0 Enhances Kubernetes Operator Development

The Java Operator SDK, a framework designed to simplify the development of Kubernetes Operators in Java, released version 5.5.0. Kubernetes Operators are a powerful concept in cloud-native computing, allowing developers to extend Kubernetes’ capabilities by encoding operational knowledge into software, automating complex application lifecycle management. The Java Operator SDK provides the tools and abstractions necessary to build robust and reliable Operators.

A significant enhancement in this release is the introduction of a complete and consistent family of update, patch, and create methods within the ResourceOperations class. These methods now fully support both RFC 6902, "JavaScript Object Notation (JSON) Patch," and RFC 7386, "JSON Merge Patch," specifications. These RFCs define standardized ways to apply partial updates to JSON documents, which is fundamental for efficient resource management in Kubernetes. JSON Patch provides a precise way to describe changes (add, remove, replace, move, copy, test), while JSON Merge Patch offers a simpler, merge-based approach. By supporting both, the Java Operator SDK empowers developers to choose the most appropriate patching strategy for their specific needs, enabling more efficient communication with the Kubernetes API server and reducing network overhead by sending only the necessary changes rather than entire resource manifests. This capability is crucial for building high-performance and scalable Operators.

Another key feature in version 5.5.0 is the new Matcher interface, which allows developers to plug in custom matching strategies into the overloaded matchAndFilter() method defined in the Options class. In the context of Kubernetes Operators, matching and filtering resources are essential for reconciliation loops, where the Operator constantly compares the desired state with the actual state of resources. The ability to define custom matching logic provides immense flexibility, enabling developers to implement advanced reconciliation patterns, handle complex resource relationships, or integrate with external systems more seamlessly. This flexibility is particularly valuable for Operators managing highly specialized or intricate application deployments, allowing for fine-tuned control over how resources are identified and processed. These enhancements collectively make the Java Operator SDK an even more powerful and versatile tool for building sophisticated and efficient Kubernetes Operators in Java.

LangChain4j 1.18.0 Introduces Advanced AI Capabilities

LangChain4j, the Java implementation of the popular LangChain framework for building large language model (LLM)-powered applications, released version 1.18.0. This release, alongside its twenty-eighth beta, significantly expands the framework’s capabilities, pushing the boundaries of what Java developers can achieve in the rapidly evolving field of artificial intelligence. LangChain4j is instrumental in creating intelligent agents, chatbots, and other AI-driven solutions by providing tools for chaining LLM calls, managing memory, and integrating with various data sources.

A groundbreaking addition in this release is the new Belief-Desire-Intention (BDI) agentic pattern. The BDI architecture is a well-established cognitive model used in artificial intelligence to design intelligent agents that can reason about their environment, form goals, and plan actions. By formalizing psychological concepts for software and robotic systems, the BDI pattern enables the creation of more sophisticated, goal-oriented, and robust AI agents. This allows LangChain4j developers to build agents that not only respond to prompts but can also maintain an internal state (beliefs), pursue specific objectives (desires), and execute plans (intentions), leading to more dynamic and adaptive AI applications. This feature significantly elevates the complexity and intelligence of agents that can be developed with LangChain4j.

Furthermore, LangChain4j 1.18.0 introduces a new TextToSpeechModel interface, providing direct support for the OpenAI Text-to-Speech (TTS) API. This integration allows developers to easily incorporate voice capabilities into their AI applications, converting textual responses from LLMs into natural-sounding speech. This opens up new possibilities for multimodal AI applications, such as voice assistants, interactive educational tools, and accessibility features, enhancing the user experience by providing an auditory dimension to AI interactions.

The release also includes the MistralAiBatchChatModel class, offering support for the Mistral Batch API. Batch processing is crucial for enterprise-level AI applications, enabling the asynchronous and cost-effective processing of large volumes of prompts. Instead of processing requests one by one, the Batch API allows developers to send multiple prompts in a single request, which can lead to significant cost savings and improved throughput for applications with high-volume or offline processing requirements. This feature is particularly valuable for analytical tasks, content generation at scale, or large-scale data annotation. These advanced AI capabilities in LangChain4j 1.18.0 solidify its position as a leading framework for building intelligent applications in the Java ecosystem, empowering developers to create more human-like, efficient, and versatile AI solutions.

Micronaut Framework 5.0.5 Delivers Maintenance Updates

The Micronaut Foundation announced the release of version 5.0.5 of the Micronaut Framework. Based on Micronaut Core 5.0.6, this maintenance release underscores the framework’s ongoing commitment to stability, reliability, and continuous improvement. Micronaut is a modern, JVM-based framework renowned for its compile-time Ahead-Of-Time (AOT) compilation, which results in incredibly fast startup times, low memory consumption, and efficient native executables, making it an ideal choice for microservices and serverless applications in cloud-native environments.

Version 5.0.5 primarily features patch updates to several key modules within the Micronaut ecosystem. These include Micronaut AWS, Micronaut gRPC, Micronaut Oracle Cloud, and Micronaut Logging. Such updates are critical for ensuring that the framework remains robust and compatible with evolving external services and technologies. For instance, updates to Micronaut AWS ensure optimal integration with the latest Amazon Web Services offerings, potentially incorporating new features or addressing changes in existing APIs. Similarly, Micronaut gRPC updates ensure that applications using this high-performance remote procedure call framework benefit from the latest improvements in communication efficiency and stability.

The updates to Micronaut Oracle Cloud are vital for developers deploying applications on Oracle’s cloud infrastructure, guaranteeing seamless interaction and leveraging specific cloud services effectively. Meanwhile, enhancements to Micronaut Logging ensure that logging mechanisms are efficient, configurable, and free from any known issues, which is fundamental for application observability and debugging in production environments.

Maintenance releases like 5.0.5 are essential for any robust software platform. They address minor bugs, improve performance, update transitive dependencies to mitigate security vulnerabilities, and ensure compatibility across the various components of the framework. By regularly issuing these updates, the Micronaut Foundation demonstrates its dedication to providing a stable and reliable platform for developers building cloud-native Java applications. The detailed release notes for Micronaut Platform v5.0.5 provide a comprehensive overview of all the changes, allowing developers to confidently upgrade their projects and benefit from the latest refinements.

Quarkus Shim: A Novel Extension for Build-Time Class Transformation

The Quarkus team introduced an intriguing new extension named "Quarkus Shim," offering a novel approach to modifying Java class behavior during the build process. Quarkus, known as the Kubernetes-native Java stack, is celebrated for its "supersonic subatomic Java" capabilities, achieving extremely fast startup times and low memory footprints through Ahead-Of-Time (AOT) compilation and native executable generation. Quarkus Shim aligns with this philosophy by enabling powerful transformations without runtime overhead.

Quarkus Shim allows developers to add, wrap, or replace behavior within a Java class during the Quarkus build phase, specifically during "augmentation." Augmentation is a unique Quarkus build-time process where the framework analyzes an application’s code and its dependencies to generate optimized bytecode, configuration files, and other artifacts. This process is what enables Quarkus to achieve its remarkable performance characteristics. The significance of Quarkus Shim lies in its ability to perform these transformations before the application is run, compiled to native code, or even packaged.

As the Quarkus team explicitly states, "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 is a critical distinction. Traditional methods of modifying class behavior at runtime often rely on Java Agents (like AspectJ or Byte Buddy), which instrument bytecode dynamically. While powerful, these agents can sometimes introduce performance overhead or compatibility issues, especially with native executables. Quarkus Shim avoids these drawbacks by applying changes during the build, resulting in static, optimized bytecode that functions seamlessly across all Quarkus execution modes, including highly optimized native images.

This experimental extension, built with Quarkus 3.37.3, opens up exciting possibilities for developers. It could be used to integrate legacy libraries that require specific runtime tweaks, implement cross-cutting concerns (like logging or monitoring) without traditional aspect-oriented programming frameworks, or even to fine-tune application behavior for specific deployment environments. The experimental status indicates that the team is seeking community feedback, but the underlying concept offers a powerful and Quarkus-native way to customize and extend application logic without compromising on performance or cloud-native suitability.

Oracle Introduces 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 strategic move aims to deeply embed advanced artificial intelligence capabilities directly into Oracle’s suite of enterprise cloud applications, including ERP, HCM, SCM, and CX. Oracle’s Fusion Cloud Applications are critical for many global enterprises, managing core business processes, and the integration of AI agents represents a major step towards intelligent automation and enhanced decision-making.

The new AI Agent Studio empowers customers to create and natively run Fusion Agentic Applications directly within their Oracle Fusion Cloud Applications environment. This means that businesses can leverage AI agents to automate complex workflows, provide intelligent assistance to users, analyze data, and proactively recommend actions, all within the context of their existing enterprise systems. For instance, an AI agent could automate invoice processing in ERP, assist HR professionals with employee queries in HCM, optimize supply chain logistics in SCM, or personalize customer interactions in CX.

A key aspect of this new builder experience is its support for "no-code, low-code, and pro-code" development. This tiered approach democratizes AI development, making it accessible to a broader range of users.

• No-code options allow business users and analysts to configure and deploy AI agents using intuitive graphical interfaces, without writing any code. This is ideal for quick automation of routine tasks.
• Low-code tools cater to citizen developers or power users, providing visual development environments with pre-built components and drag-and-drop interfaces, accelerating development for more complex scenarios.
• Pro-code capabilities are designed for experienced developers, offering full programmatic control to build highly customized and sophisticated AI agents, integrating with external services and leveraging advanced AI models.

This comprehensive framework integrates all development levels into a single Fusion-native environment, fostering collaboration between different user groups and ensuring that AI solutions are seamlessly woven into the fabric of enterprise operations. It is important to note that both AI Agent Studio and Fusion Cloud Applications are subscription services, reflecting Oracle’s cloud-centric business model and its focus on delivering high-value, managed AI solutions to its enterprise customer base. This initiative positions Oracle to provide a powerful, integrated AI platform that promises to drive greater efficiency, intelligence, and competitive advantage for businesses leveraging its Fusion Applications.