By open-sourcing the project, we’re inviting the community to contribute, extend, and innovate, helping shape a more powerful and inclusive AI development experience for everyone in the open source ecosystem. 

Why are we open‑sourcing Copilot for Eclipse?

Over the last few months, we’ve heard consistent requests from the community and from many active users of GitHub Copilot for Eclipse to open source the project. At the same time, many core interaction patterns and integration approaches have matured, making it a good moment to open the code and enable the community to refine and build on these shared experiences.

Open‑sourcing the GitHub Copilot for Eclipse plugin allows us to be more transparent about how the plugin works, welcome broader community contributions, and evolve the product in closer collaboration with Eclipse developers and maintainers.

What’s next?

We’ll continue to: 

• Evolve GitHub Copilot features in Eclipse
• Work closely with the developer community 
• Explore additional collaboration opportunities as the ecosystem evolves

The post GitHub Copilot for Eclipse Is Going Open Source appeared first on Microsoft for Java Developers.

We recently released a step-by-step course from simple chat to AI agents using LangChain4j http://aka.ms/LangChain4j-for-Beginners

Now watch the new 6⃣part Video series with tons of hands-on demos.

Let’s break down what you’ll learn.

1. Introduction to LangChain4j

Every journey starts with a working app. In this first session, you’ll connect to Azure OpenAI GPT-5, send your first prompts, and immediately see results. But the real insight comes when you add memory: watch a simple stateless demo transform into a production-ready conversational AI, side by side. Along the way, you’ll build intuition for tokens and context windows — the invisible constraints that shape everything your AI can do.

2. Prompt Engineering with LangChain4j

Now that your app is running, the question becomes: how do you ask the right questions? The same model gives wildly different results depending on how you prompt it. This session covers eight prompting patterns that control GPT-5’s reasoning depth — from quick calculations to deep architectural analysis. You’ll write self-reflecting prompts that iterate until code meets quality criteria, structured analysis frameworks for consistent reviews, and chain-of-thought techniques that make the AI’s reasoning visible.

3. Data-Driven Apps with RAG

Great prompts go a long way — but your AI still only knows what it learned during training. Retrieval-Augmented Generation (RAG) changes that. In this session, you’ll build a complete RAG pipeline: chunk documents, create semantic embeddings, and retrieve relevant context for every question. By the end, your AI answers questions about your own files with source citations and confidence scores — grounded in facts, not hallucinations.

4. Tools, MCP, and Agents

So far, your AI reads and responds. Now it’s time to make it act. You’ll expose Java methods as tools using @Tool annotations and watch the AI chain them automatically with the ReAct pattern. From there, you’ll explore the Model Context Protocol (MCP) — an open standard for AI-to-tool communication — and build a Supervisor Agent that dynamically orchestrates sub-agents to read files, analyze content, and summarize results. This is where your AI stops being a text generator and becomes an action taker.

5. Safety, Reliability & Best Practices

An AI that can take action needs guardrails. This session is about building applications that are safe, reliable, and enterprise-ready. You’ll learn how to protect API keys and model endpoints, validate tool output, enforce content filters, and keep LLMs from stepping outside their intended boundaries. On the defensive side, you’ll design prompts that resist injection attacks, restrict system capabilities through structured interfaces, and implement patterns for secure RAG, safe memory handling, and audit-ready logging. The result: LangChain4j applications your team — and your users — can trust.

With special Guest Brian Benz

6. Agentic Patterns

In this finale, we graduate from single agents to full multi-agent systems. You’ll explore eight patterns that power production AI: chain agents like an assembly line, fan-out for parallel expert opinions, loop until a critic approves, and route requests to the right specialist. Then go further with Supervisor agents that delegate like project managers and Human-in-the-Loop gates for when a person needs the final say. Finally, discover goal-oriented planners that find optimal paths and peer-to-peer meshes where agents collaborate as equals — no boss required.

With special Guest Mario Fusco

Final Thoughts

In six sessions, you’ve gone from “Hello, AI” to orchestrating multi-agent systems.

Enjoy the above video series and explore, star and fork its repository https://github.com/microsoft/LangChain4j-for-Beginners

The post 📢LangChain4j got a new video series appeared first on Microsoft for Java Developers.

Timeline of Deprecation 

In the next few months, GitHub Copilot plugin will discontinue support for JetBrains IDEs versions 2024.2 and 2024.3.

Who Is Affected 

This change applies to GitHub Copilot users on JetBrains IDEs versions 2024.2 and 2024.3; version 2025.1 and later versions remain fully supported.  

What Happens If You Stay on JetBrains IDEs Versions 2024.2 or 2024.3 

If you continue using JetBrains IDEs versions 2024.2 or 2024.3 after support ends: 

• Your current GitHub Copilot functionality will remain unchanged and continue to work.
• Future GitHub Copilot updates may not be compatible with these versions.
• You will no longer receive bug fixes, performance improvements, or new features for these versions. 

 What We Recommend 

To continue using GitHub Copilot with full support: 

1. Check your current IDE version:

• Windows/Linux: Go to Help > About in your JetBrains IDE 
• macOS: Go to [IDE Name] > About [IDE Name] (e.g., IntelliJ IDEA > About IntelliJ IDEA) 

The version number will be displayed in the dialog. 

2. Based on your version:

• If you’re on version 2025.1 or later: You’re all set and can skip the remaining steps. 
• If you’re on version 2024.2 or 2024.3: Upgrade to version 2025.1 or later by visiting the JetBrains download page. 

3. Update GitHub Copilot plugin: After upgrading, ensure your GitHub Copilot for JetBrains IDEs plugin is up to date by going to Settings > Plugins and checking for updates. 

FAQ 

• Does GitHub Copilot stop working immediately on JetBrains IDEs versions 2024.2 and 2024.3? 

No. GitHub Copilot plugin will continue to function on JetBrains IDEs versions 2024.2 and 2024.3, but without any support or updates after support ends. 

• Why is support being discontinued for versions 2024.2 and 2024.3? 

Supporting older JetBrains platform versions limits our ability to deliver improvements and maintain compatibility with newer IDE APIs and tooling. 

• What version should I upgrade to? 

We recommend upgrading to version 2025.1 or later to ensure continued support and access to the latest GitHub Copilot features. 

Share your feedback 

Your feedback drives improvements. We’d love to hear about your experience in the following channels: 

– In-product feedback: Use the feedback options within your IDE. 

– Feedback repository: Share your thoughts in the GitHub Copilot for JetBrains IDEs issues. 

The post Important updates: GitHub Copilot support ending for JetBrains 2024.2 and 2024.3 appeared first on Microsoft for Java Developers.

You’ve probably heard some version of “AI will write all the code.” In practice, what we’re seeing is simpler (and more useful): AI helps take the busy work out of your day so you can spend more time on the work that needs a Java engineer. That means architecture decisions, performance tradeoffs, correctness, security, and the kind of operational thinking that keeps systems running.

What we’re bringing to JavaOne

So, what are we going to talk about at JavaOne? We’ll share how Java teams are building real AI features, supported by your favorite AI models that are grounded in the right data, evaluated for quality, and operated with the same discipline you apply to your applications today. And we’ll show what that looks like on Azure, whether you’re modernizing your applications or running the latest code on serverless, containers, Kubernetes, and beyond.

We’ll also spend time on what makes agents trustworthy. Java engineers are right to ask: how do we make sure these systems behave like our best teammates? The answer is guardrails: clear roles, permissions, and policies; strong grounding so responses are tied to the right context; and continuous evaluation so you can define what “good” looks like and enforce it. When agents are treated like software (with testing, monitoring, and security), they become a practical way to ship new AI capabilities that are safe and scale.

Microsoft’s commitment to the Java ecosystem

Microsoft is deeply invested in Java’s success. We partner across the ecosystem and contribute upstream so Java stays open, portable, and production‑ready, including ongoing contributions to projects like LangChain4j and Spring AI (from model integrations and SDK alignment to security fixes, documentation, and reference architectures). We also keep investing in developer productivity across the tools you already use like IntelliJ and Eclipse, so teams can move faster while staying in control, especially when it comes to modernizing existing applications and bringing them forward into modern Java.

If you’re curious what Microsoft’s Java team has been building, check us out at JavaOne, starting with the keynote, then a set of technical sessions, and a fantastic roster of experts and theatre sessions at the Microsoft booth where you’ll have the opportunity to go deeper.

Microsoft sessions at JavaOne

Day 1 Keynote: Java for an AI World

Tuesday, Mar 17 | 8:30 AM – 9:30 AM PDT Auditorium

The keynote streams live on March 17 at 15:30 UTC at youtube.com/java — join us on stage alongside Rod Johnson, Josh Long, and engineering leads from Oracle, NVIDIA, JetBrains, and Uber for what’s shaping up to be one of the most compelling keynotes in JavaOne’s recent history.

Technical Sessions

Copilot in Your Java Tooling: From CLI to SDK to Plugins – Bruno Borges

Tuesday, March 17 | 10:30–11:20 AM PDT Room 104

See how GitHub Copilot CLI and the Copilot Community SDK for Java enable embedding Copilot into custom tools, workflows, and Java-based developer platforms.

Production-Ready GenAI with Open Models for Java Teams – Brian Benz

Tuesday, March 17 | 11:30 AM–12:20 PM PDT Room 104

Learn how Java teams build and operate production GenAI systems using open models with frameworks and tools like LangChain4j and vector search, including tuning, safety, and RAG quality evaluation.

Building and Using the Java SDK for Copilot Using AI Agents – Bruno Borges

Tuesday, March 17 | 2:00–2:50 PM PDT Duke’s Meals

Explore the Java SDK for Copilot, which brings programmatic control of the Copilot CLI and its agents to the Java ecosystem, including conversational AI sessions, custom tools, streaming events, and MCP server integration.

Meet us at the Microsoft booth

You can also connect with Patrick Chanezon, Bruno Borges, Naga Surendran, Beena Moore, Ayan Gupta and myself throughout the event to discuss Java modernization, platform engineering, containers, and AI-powered development.

Visit the Microsoft booth #2 for demos, technical conversations, and a chance to win a Microsoft Store gift card in our sweepstakes. While you’re there, stick around for some fun — we’ll have swag and surprises waiting.

We look forward to seeing you at JavaOne 2026!

That’s not all! The learning continues in a couple of weeks. Join us for JDConf 2026 on April 8-9, a free, global virtual conference for and by Java developers, now in its sixth year! RSVP here for a chance to win exciting prizes

Resources

• • Java on Azure Build and run Java applications on Azure. https://learn.microsoft.com/azure/developer/java/
  • Microsoft Foundry Secure model deployment and management platform. https://azure.microsoft.com/ai/foundry
  • GitHub Copilot App Modernization App assessment and modernization with Copilot App Mod. https://learn.microsoft.com/github/copilot/app-modernization
  • JavaOne 2026 Demo Code and Samples Demo code from Microsoft’s JavaOne sessions. https://aka.ms/javaonedemo
  • Microsoft for Java Developers Java at Microsoft: 2025 Year in Review https://devblogs.microsoft.com/java/java-at-microsoft-2025-year-in-review/

Follow @JavaAtMicrosoft on social media

The post Microsoft at JavaOne: Empowering Java developers to lead the next era of AI appeared first on Microsoft for Java Developers.

This year, Microsoft is bringing that energy to Cologne, Germany, April 20-23, 2026, at the iconic Cinedom Multiplex Cinema. We are thrilled to represent the Microsoft Java teams at one of Europe’s most beloved community-driven Java conferences. JCON has the spirit we show up with. No fluff, no filler. Just real engineering problems, real solutions, and real conversations with the people building production Java systems every day.

Attend JCON Europe for free as a Guest of Microsoft

JCON Europe is an in-person event in Cologne – and we want you there. Microsoft has a limited number of complimentary passes to share with the Java community. 

Claim your free ticket using the link below – but act fast, coupons are limited!

Cologne is a great city, the Cinedom is a one-of-a-kind conference venue, and the JCON hallway track is worth the trip on its own. Come see us live, and stay for the rest of the program and the other amazing speakers – there’s a lot of great content this year.

What Microsoft Is Doing for Java

Before we get into the sessions, a quick word on why we’re here. Microsoft is deeply invested in the Java ecosystem. Not just as a cloud platform, but as an active contributor to the community. This includes our  Microsoft Build of OpenJDK, our investments in Java tooling across Azure and Microsoft Foundry, and our work embedding Java-first experiences into GitHub Copilot.

From running millions of Java workloads in Azure production environments to contributing to upstream OpenJDK and frameworks like Spring, LangChain4j, and Quarkus, Microsoft is a Java shop. We want Java developers to succeed – on any cloud, with any framework, using tools that genuinely make their lives easier. That’s what we’re bringing to Cologne.

Our Sessions at JCON Europe 2026

Workshop: Modernizing Java Applications with AI Assisted Workflows

Monday, April 20 | 13:00-15:00 | Workshoproom: Koln/Bonn | Sandra Ahlgrimm & Bruno Borges

In this hands-on lab, we combine GitHub Copilot with OpenRewrite to modernize a real Java project – assessing the codebase, generating an upgrade plan, applying automated transformations, and validating the results. You will leave with safe prompting patterns and repeatable modernization recipes you can apply at work immediately.

Session details & registration: schedule.jcon.one/2026/session/1076678

Note: to attend the workshop, a separate ticket is required. 

Conference Session: Secrets of Performance Tuning Java on Kubernetes

Tuesday, April 21 | 13:30-14:15 | Cinema 6 | Bruno Borges

Getting Java to run on Kubernetes is easy. Getting it to run well is where things get complicated. This session digs into the JVM’s inner workings in containerized environments – GC defaults, heap sizing, CPU throttling under Linux CFS scheduling – and helps Ops engineers, SREs, and Java developers make informed decisions about vertical vs. horizontal scaling for both performance and cost.

Session details: schedule.jcon.one/2026/session/1044547

Resources

• Microsoft Azure Summit: Migrate and Modernize with Agentic AI – Global in-person event series

• GitHub Copilot App Modernization: App assessment and modernization with Copilot App Mod

• Java and AI for Beginners YouTube Series: Essential first steps of working with generative AI in Java

• Microsoft Foundry: Secure model deployment and management platform

• Java Demo Code and Samples: SkiShop – Legacy to Modern Application Migration Demo

• Java AI Samples on Azure: learn.microsoft.com/azure/developer/java/ai

• Azure Command Launcher for Java: aka.ms/jaz

• Microsoft for Java Developers: Java at Microsoft: 2025 Year in Review

Upcoming Events

• April 8-9 | Microsoft JDConf 2026: Virtual Java Developer Conference: jdconf.com

• April 20-23 | JCON Europe 2026 – Cologne, Germany: 2026.europe.jcon.one

The post JCON Europe 2026: Java Modernization, Performance, and AI appeared first on Microsoft for Java Developers.

Registration is now open. Visit jdconf.com for updates.

The Voices Shaping Modern Java at Microsoft JDConf 2026

Across industries, AI is moving from experiments to production systems that require scale, reliability, and governance. Java remains central to making that shift possible inside the enterprise platforms businesses already depend on.

JDConf 2026 brings together leading voices from across the global Java ecosystem and top technology companies who are shaping that evolution in real time. Sneak peek at this year’s featured sessions: a strong Java-focused lineup led by engineers and architects working deep in the JVM ecosystem. These talks zero in on modern Java development, performance, cloud-native architectures, and pragmatic approaches to bringing AI into Java applications without adding unnecessary risk.

Java & AI-Native Architectures

From Cloud Native to AI Native: Harnessing Quarkus, MCP, and Azure OpenAI Daniel Oh, Senior Principal Developer Advocate, Red Hat & IBM

Daniel is a Java Champion with deep experience in cloud native Java and open-source ecosystems. At JDConf 2026, he will build a Quarkus microservice that connects enterprise systems through MCP and integrates Azure OpenAI, showing how to move from a standard cloud native service to a production-ready AI-enabled application.

Bootiful Spring AI Josh Long, Spring Developer Advocate, Broadcom

Josh has been the first Spring Developer Advocate since 2010 and is known for his fast-paced, code-first demos and unmistakable stage presence. Bringing his trademark energy to JDConf 2026, he’ll show how to integrate AI into Spring Boot applications using Spring AI, walking through practical examples that make modern AI integration feel accessible and immediate for Java developers.

Java RAG Made Easy with Spring AI and Elasticsearch Laura Trotta, Senior Software Engineer, Elastic

Laura maintains the official Java client for Elasticsearch and actively contributes to Spring AI, Spring Data, and Spring Boot. In this session, she’ll demonstrate how to build a retrieval-augmented generation pipeline in Java using Spring AI and Elasticsearch as a vector store, showing how to turn private data into a domain-specific chatbot with a practical, live demo.

Agentic Systems & Memory

Secrets of Agentic Memory Management Principal Applied AI Engineer, Redis

Brian is a Java Champion and Principal Applied AI Engineer at Redis with more than three decades of experience building production systems. In this session, he’ll break down how modern agents manage short- and long-term memory, covering summarization, semantic retrieval, promotion, and consolidation, and show practical strategies for building memory-aware Java agents using tools like MCP.

Self-Improving Agentic Systems with Spring AI R&D Software Engineer, Spring Team at Broadcom

Christian leads the Spring AI and MCP Java SDK projects, helping shape how AI is built into the Spring ecosystem. In this session, he’ll demonstrate how to design agents that iterate, call tools, and refine their outputs using Spring AI’s Advisor model, moving beyond simple prompt-response patterns.

How to Build and Orchestrate Scalable Multi-Agent AI Systems Mary Grygleski, VP Global AI Collective & Java Champion

Mary is a Java Champion, technical architect, and long-time community leader with deep experience in distributed systems and streaming platforms. In this session, she’ll demonstrate how to design multi-agent AI systems in Java using event-driven patterns such as pub/sub and orchestration, showing tools like Kafka, Pulsar, Spring Messaging, and MCP enable scalable, coordinated agent workflows.

You’re Absolutely Right, It Was Your Home Directory! Oleg Šelajev, AI & Developer Relations, Docker

Oleg is a Java Champion, Microsoft MVP, and Docker Captain focused on AI-driven developer productivity and Testcontainers. In this session, he’ll demonstrate how Docker Sandboxes provide controlled environments for AI agents, showing how to run agent-driven development workflows safely without risking your filesystem, secrets, or local machine.

Real-World Modernization

How the Dutch IRS Implemented AI-Assisted App Modernization  Java Enthusiast & Special Agent, Team Rockstars IT

Ron Veen has over 20 years of JVM experience spanning mainframes and modern cloud-native systems. In this session, he’ll walk through how the Dutch IRS migrated from a monolith to Kubernetes-based microservices using AI-assisted development in a tightly regulated environment, sharing practical lessons from modernizing sensitive enterprise systems with Copilot Studio.

Modern Java & Testing

Playwright: Your Next Java Test Framework for Automating Web Tests Alex Soto, Developer Advocate, IBM

Alex Soto is a Java Champion, author, and long-time advocate for automation and open source in the Java ecosystem. In this session, he’ll introduce Playwright for Java, demonstrating how to build resilient, cross-browser web tests, generate test code, and use built-in tooling such as reporting and session replay to better understand and debug test failures.

DevOps & Security

Deploying to Production with Confidence Andres Almiray, Seasoned Sourceror

Andres Almiray is a Java Champion and long-time open-source contributor with over two decades in the Java ecosystem. In this session, he’ll cover practical software supply chain security topics such as SBOMs, SLSA, reproducible builds, and CI/CD hardening, outlining how teams can reduce risk before deploying to production.

RSVP Now

Microsoft JDConf 2026 is a free global virtual event streamed live across three time zones. It brings together Java developers and architects from around the world to share real-world experience with the latest advancements in Java, cloud, and AI.

Register today at jdconf.com to join the conversation and earn Microsoft Rewards while learning directly from the engineers and community leaders shaping modern Java. More speakers and sessions will be announced soon. Join us to learn more about the modern Java solutions for an agentic world!

The post Meet the First Round of Speakers for Microsoft JDConf 2026 appeared first on Microsoft for Java Developers.

This year’s DevNexus agenda reflects where the Java ecosystem is heading. With dedicated tracks for AI Engineering, Generative AI, and AI in Practice, the conversation has clearly moved beyond experimentation. Developers want to know what works, what scales, and what’s safe to put into production. That’s exactly the lens we’re bringing to Atlanta. Microsoft will be onsite throughout the week, sharing real-world lessons and strategic insights from thousands of customers running Java in production, broadly divided into three focus areas: 

Reimagining the developer experience with Agentic DevOps: Agentic DevOps supercharges productivity by putting AI agents to work across every stage of software delivery. Java teams can ship faster, slash operational costs, and boost product quality by automating everything from code generation and testing to deployment and monitoring. Agentic DevOps is deeply integrated into GitHub, GitHub Copilot, and Azure, helping teams offload repetitive work and focus on building, reviewing, and shipping software that creates real value for customers.  

An agentic platform for end-to-end delivery: Azure and Microsoft Foundry power a seamless delivery pipeline, automating code analysis, app modernization, and production optimization. This means less time spent on tedious tasks, and more time driving innovation that moves the business forward. For businesses, this means accelerated time-to-market, reduced technical debt, and the ability to adapt quickly to changing market needs, turning software teams into engines of business growth.  

AI powered Java migration and modernization: By combining GitHub Copilot App Mod tooling with Azure application platform services, Microsoft empowers Java teams to migrate legacy apps to the cloud, modernize architectures, and unlock AI-enabled development. The result is lower infrastructure costs, greater agility, and scalable platforms that support continuous innovation.  

Sessions focused on the end-to-end AI Journey 

My colleague Brian Benz, Principal Cloud Advocate at Microsoft, and I are bringing practical, hands-on content that spans the entire AI journey, from modernization to responsible deployment.

Hands-on-workshop: Modernize Apps with AI Agents Wednesday, March 4 | 1:00 PM – 5:00 PM ET

Attend this half-day workshop with Brian Benz and me to explore how AI agents can address modernization tasks such as scanning extensive codebases, developing upgrade plans, and automating repetitive processes that typically require months to complete. Participants will have the opportunity for hands-on experience with GitHub Copilot and Azure AI. Register now—limited seats are available and going fast.

Security track: Responsible Java Developer: Trustworthy GenAI in Practice Friday, March 6 | 1:20 PM ET

As AI moves from experimentation to production, Java developers face real questions around privacy, bias mitigation, safety, and governance. In this session, Brian discusses practical ways to design and deploy trustworthy GenAI systems, with guidance drawn from Microsoft’s Responsible AI standards and engineering experience. https://devnexus.com/events/the-responsible-java-developer-trustworthy-genai-in-practice

AI Engineering track: AI Agents for Java Devs: From Demo to Deployment Friday, March 6 | 3:40 PM ET

With the current pace of change, many Java developers feel overwhelmed by the number of tools and models, multiple starting points, and uncertainty about how it all fits within their existing environments. Brian’s session shows how to move from cool demos to production-ready solutions, using accessible AI agents for planning, coding, and scaling with GitHub Copilot, Azure AI, and open-source tools. https://devnexus.com/events/ai-agents-for-java-devs-from-demo-to-deployment

Why This Matters Now 

Over the past year, we continued investing directly in the Java ecosystem, both upstream and in production environments. With the release of OpenJDK 25 and Microsoft Build of OpenJDK 25 as the newest Long-Term Support release, we delivered cross-platform binaries, container images, managed Azure platform support, and production-grade validation across enterprise workloads. We also introduced the Azure Command Launcher for Java (“jaz”), which applies intelligent JVM defaults to improve GC stability, startup behavior, and performance consistency at scale. These investments reinforce a simple principle: AI innovation only matters if the underlying Java platform remains stable, performant, and production-ready.

As AI becomes embedded in daily development workflows, the conversation for Java teams is less about hype and more about integration. The real question is how new capabilities fit into existing JVM estates, established frameworks, and long-running production systems. The focus remains on practical modernization, predictable performance, secure design, and operational discipline. These DevNexus sessions examine real engineering trade-offs such as upgrading LTS baselines, modernizing frameworks, tuning JVM behavior, and introducing AI responsibly into mature Java environments, grounded in hands-on experience with large production Java workloads.

Visit Microsoft Booth!  

Stop by to explore tools and demos that support Java developers across the stack, including Azure, GitHub Copilot, and open‑source AI capabilities.  We look forward to seeing you in Atlanta. 

Register at devnexus.com 

Resources 

Below are key links referenced in this post for further reading and hands-on learning: 

• GitHub Copilot App Modernization App assessment and modernization with Copilot App Mod.

• Java and AI for Beginners YouTube Series Essential first steps of working with generative AI in Java

• Microsoft Foundry Secure model deployment and management platform.

• Java Demo Code and Samples SkiShop – Legacy to Modern Application Migration Demo

• Java AI Samples on Azure https://learn.microsoft.com/azure/developer/java/ai 

• Azure Command Launcher for Java https://aka.ms/jaz

• Microsoft for Java Developers Java at Microsoft: 2025 Year in Review

Upcoming events 

• February 14 | Microsoft Reactor: Modernize your Java apps in Days with AI Agents https://aka.ms/ADL/Feb17-b
• March 10-12 | JavaLand 2026 https://www.javaland.eu/en/home/
• March 11 | Microsoft Reactor: AI Apps & Agents Dev Days (Morning Session) https://developer.microsoft.com/en-us/reactor/events/26660/
• March 11 | Microsoft Reactor: AI Apps & Agents Dev Days (Afternoon Session) https://developer.microsoft.com/en-us/reactor/events/26683/
• March 17-19 | JavaOne 2026 https://www.oracle.com/javaone/
• April 8-9 | Microsoft JDConf 2026: Virtual Java Developer Conference https://jdconf.com 

The post Microsoft at DevNexus 2026: Practical AI for Real-World Java Development appeared first on Microsoft for Java Developers.

We are happy to announce the latest January 2026 patch & security update release for the Microsoft Build of OpenJDK. Download and install the binaries today.

• OpenJDK 25.0.2
• OpenJDK 21.0.10
• OpenJDK 17.0.18
• OpenJDK 11.0.30

Check our release notes page for details on fixes and enhancements. The source code of our builds is available now on GitHub for further inspection: jdk25u, jdk21u, jdk17u, jdk11u.

Microsoft Build of OpenJDK specific updates

OpenJDK25

• No Microsoft-specific updates for this release.

OpenJDK21

• No Microsoft-specific updates for this release.

OpenJDK17

• No Microsoft-specific updates for this release.

OpenJDK11

• No Microsoft-specific updates for this release.

Summary of Upstream Updates

OpenJDK 25

• List of fixes
• See the OpenJDK Vulnerability Advisory

OpenJDK 21

• List of fixes
• See the OpenJDK Vulnerability Advisory

OpenJDK 17

• List of fixes
• See the OpenJDK Vulnerability Advisory

OpenJDK 11

• List of fixes
• See the OpenJDK Vulnerability Advisory

OpenJDK 8

We continue to provide support on Azure and internally at Microsoft for OpenJDK 8 binaries of Eclipse Temurin built by the Eclipse Adoptium project. To facilitate its usage, we ship container images of OpenJDK 8 on top of Azure Linux and Ubuntu. Refer to our documentation.

OpenJDK 8 (latest)

Questions?

Contact openjdk-support@microsoft.com.

Amplify the news!

LinkedIn

The post Java OpenJDK January 2026 Patch & Security Update appeared first on Microsoft for Java Developers.

What is Azure Performance Diagnostics Tool for Java via Azure SRE Agent?

The Azure Performance Diagnostics Tool for Java is a powerful new capability within Azure SRE Agent, an AI-powered service that automatically responds to site reliability issues. This feature enables development and operations teams to monitor, analyze, and troubleshoot Java Virtual Machine (JVM) performance issues with unprecedented ease.

Azure Performance Diagnostics Tool for Java can identify and diagnose common JVM problems, including:

• Garbage collection inefficiencies and pauses
• CPU resource utilization issues (both under- and over-utilization)
• Excessive I/O operations impacting application performance
• Thread contention

An example of a report highlighting a garbage collection issue would be as follows:

How Does It Work?

When Azure SRE Agent is tasked with solving a performance issue by the customer and it suspects that a JVM related issue is the cause, the agent immediately initiates a comprehensive diagnostic report. This allows your team to understand the root cause of this performance issue.

Teams can also manually request diagnostics through the Azure SRE Agent chat interface. Simply ask for a performance analysis of any Java service; you can even build your own Sub-Agent and integrate the AKS performance functions as part of that Sub-Agent. You can then directly ask your agent to perform Java diagnoses:

Take a look at it in action in the video below.

The Java Performance Diagnostic Process

When Azure SRE Agent suspects a performance issue (or is manually invoked to perform a Java performance investigation in your container), it:

1. Spins up an ephemeral container within your pod
2. Attaches to the target Java container without disrupting service
3. Collects detailed performance telemetry using Java Flight Recorder (JFR)
4. Analyzes the data and generates actionable insights
5. Closes down the ephemeral container once the analysis is complete

This approach ensures zero downtime while providing deep visibility into JVM behaviour.

NOTE: For auditability reasons the Kubernetes API retains visibility of terminated ephemeral containers. As a result when looking at a pod for instance using kubectl describe pods the ephemeral containers will be visible, to prevent excessively generating noise within your environment, we have limited the pod to having run 5 diagnostic containers.

Getting Started

Setting up JVM Diagnostics is straightforward. Here are the requirements:

• Java applications deployed in AKS – Your Java services must be running within an Azure Kubernetes Service cluster
• Azure SRE Agent configuration – Ensure your Azure SRE Agent service is created and has appropriate access to your AKS cluster
• Pod annotation – Add the languageStack=java annotation to your pods to enable Azure Performance Diagnostics Tool for Java

Note: At time of writing the Java profiling feature is in the Early access features, to enable early access, within the SRE Agent UI, browse to Settings, Basics, and select  Early access to features. The feature will progress to main line in the coming month.

Adding the required annotation is as simple as updating your pod specification:

apiVersion: v1
kind: Pod
metadata:
  name: your-java-app
  annotations:
    languageStack: java
spec:
  containers:
    - name: app
      image: your-java-app:latest

Alternatively, you can apply an annotation on the command line using kubectl:

kubectl annotate pod your-java-app languageStack=java

Annotating your pods indicates that they are running Java applications and that you consent to have them diagnosed using Azure Performance Diagnostics Tool for Java. As always with monitoring, although the diagnostic process is designed to be as non-intrusive as possible, there is a small amount of overhead involved when running the Java Flight Recorder profiler and the diagnostic container. It is recommended to first use this feature in non-production environments and ensure that the diagnostic process does not interfere with your application.

Build your own Sub-Agent

You can also create a custom Sub-Agent within Azure SRE Agent, and delegate to the AKS diagnostic analysis tools, in order to create an agent specifically for how you wish to respond to AKS diagnostic needs. You can also delegate to this agent when responding to an alert. The following is an example of how to configure a Sub-Agent which includes the Java Performance Diagnostic capability via the SRE Agent GUI:

Below is an example YAML configuration that can be pasted into the YAML input dialogue within the create a SRE Sub-Agent Builder UI:

api_version: azuresre.ai/v1
kind: AgentConfiguration
spec:
  name: AKSDiagnosticAgent
  system_prompt: >-
    Take the details of a diagnostic analysis to be performed on a AKS container and hand off to the
    appropriate diagnostic tool. If you need to find the resource to diagnose, use the
    SearchResourceByName and ListResourcesByType tools
  tools:
    - GetCPUAnalysis
    - GetMemoryAnalysis
    - SearchResourceByName
    - ListResourcesByType
    - AnalyzeJavaAppInAKSContainer
  handoff_description: >-
    When the user has requested a diagnostic analysis, or it has been determined an AKS diagnostic
    analysis is required
agent_type: Autonomous

You can then interact with this Sub-Agent via the Azure SRE Agent chat interface to request JVM performance analyses as needed, for instance:

/agent AKSDiagnosticAgent I am having a performance issue in:
pod: illuminate-test-petclinic
container: spring-petclinic-rest
namespace: illuminate-test
aks instance: jeg-aks

This will trigger the Azure Performance Diagnostics Tool for Java process and return a detailed report of findings and recommendations.

The post Introducing Azure Performance Diagnostics Tool for Java: Automated Java Performance Analysis in Kubernetes via Azure SRE Agent appeared first on Microsoft for Java Developers.

2025 was one of the most significant years yet for Java at Microsoft. From the arrival of OpenJDK 25 as the newest Long‑Term Support (LTS) release, to AI‑powered modernization workflows with GitHub Copilot app modernization, to Agentic AI development in Microsoft AI Foundry with Java frameworks like LangChain4j, Spring AI, Quarkus AI, and Embabel, with major Visual Studio Code and Azure platform investments. Microsoft deepened its commitment across the entire Java ecosystem.

Java 25: A New LTS Era Begins

2025 delivered a historic milestone: OpenJDK 25 officially shipped and with it, Microsoft Build of OpenJDK 25 as the next Long‑Term Support (LTS) release, setting the foundation for the next multi‑year cycle of enterprise Java workloads.

For developers who have not been following advancements in the Java language, it may not look, but the code below is a Rock Paper Scissors implementation in Java 25 that can be put inside a Game.java file and executed with “$ java Game.java” with a JDK 25 installation.

To run this code, Microsoft released binaries, container images, and updated Azure Platform services, providing:

• Cross‑platform availability on Linux, macOS, and Windows for both x64 and AArch64/Apple Silicon
• Azure Platform services App Service and Functions with managed JDK 25
• Container images via the Microsoft Container Registry
• Production‑ready quality gates, including JCK compatibility, Eclipse AQAvit verification, and Microsoft’s internal performance hardening
• AI-assisted upgrade and modernization path from JDK 8, 11, 17, and 21 through GitHub Copilot app modernization

With Java 25, enterprises gain language and runtime improvements, performance upgrades, memory optimizations, and new developer‑facing capabilities, giving organizations strong justification to plan migrations earlier in the LTS cycle rather than waiting several years. To learn about some of the new features in JDK 25, check our announcement.

GitHub Copilot across Java IDEs: Eclipse & IntelliJ

GitHub Copilot’s continued parity and agentic capabilities across Visual Studio Code, IntelliJ IDEA, and Eclipse IDE ensure Java teams can adopt AI assistance without changing IDEs, which is crucial for regulated environments and large estates. The advantage of GitHub Copilot is to bring to developers all the best coding models through a single subscription.

In IntelliJ IDEA, the official GitHub Copilot plugin delivers chat, agentic capabilities, MCP support, inline completions, and more. Fast nightly updates keep pace with IDE releases across the JetBrains family. GitHub Copilot is also available on the Eclipse Marketplace with code completions, Copilot Chat, and agentic workflows powered by Agent Mode and MCP integrations. Agent preview lets developers delegate tasks from Eclipse and track jobs that open draft PRs and queue reviews.

• Install in IntelliJ from JetBrains Marketplace
• Install in Eclipse from Eclipse Marketplace

GitHub Copilot CLI: beyond IDEs

For Java developers who prefer working directly from the terminal, the GitHub Copilot CLI brings the same AI‑assisted power found in IDEs straight to your shell. With Copilot CLI, you can run development tasks, upgrade, migration, and deployment workflowsend‑to‑end without switching tools, ideal for developers who live in Bash, Zsh, or PowerShell. Copilot CLI supports interactive and batch scenarios, making it possible to develop Java applications, upgrade Java versions, modernize Spring or Jakarta EE apps, or deploy to Azure entirely via command‑line tasks.

GitHub Copilot App Modernization: A Breakthrough for Java and Frameworks Upgrades

2025 was a breakout year for Java modernization via GitHub Copilot, now providing end‑to‑end support for assessments, planning, code transformation, testing, and deployment. For a video introduction, watch Modernize Java apps in days with GitHub Copilot on YouTube.

Modernization formulas, rules, and recipes encode expert migration guidance for core Java APIs, the Spring Framework, the Jakarta EE platform, and hundreds of related scenarios including logging, identity, secret management, messaging, database, and overall cloud readiness.

Key modernization capabilities:

• Deep codebase analysis (framework versions, deprecated APIs, dependency issues)
• AI‑generated modernization plans
• Automated and deterministic code transformations and refactoring
• Security CVE detection, build remediation, and test generation
• Azure‑optimized deployment paths

GitHub Copilot app modernization is available on Visual Studio Code, IntelliJ, and in the Copilot CLI.

Azure Command Launcher for Java: Intelligent JVM Defaults and More

2025 was also the year when JVM tuning became a no-brainer for cloud‑native Java teams. Now in Public Preview, the Azure Command Launcher for Java is a drop‑in replacement for the java JVM launcher that:

• Eliminates the need for manual JVM tuning
• Applies smarter, optimized JVM flags and configurations automatically
• Reduces memory waste and inconsistent tuning across your fleet
• Improves startup, GC behavior, and resource efficiency
• Properly detects environment memory and CPU limits
• Supports OpenJDK 8 and later

Large organizations like Bradesco Bank validated operational gains, demonstrating measurable efficiency enhancements, performance consistency, and operational peace of mind across hundreds of thousands of JVMs. The tool provides an immediate path for teams modernizing to the new LTS without having to learn completely new tuning heuristics. Let us do the JVM tuning for you.

Once installed, using Azure Command Launcher for Java is as simple as replacing the “java” command with the “jaz” command:

For more information on the performance benefits, check the article Beyond Ergonomics: How the Azure Command Launcher for Java Improves GC Stability and Throughput on Azure VMs.

The roadmap for the Azure Command Launcher for Java has exciting ideas, and we are eager to connect with developers and customers willing to experiment. Let us help you get the most of advanced JVM features like App CDS, Project Leyden, GC log analysis, and more!

Azure SRE Agent: Intelligent Reliability for Java Apps

Announced this year and currently in Preview, the Azure SRE Agent is soon adding deeper operational intelligence for Java workloads. Java teams running at scale gain a powerful assistant that reduces MTTR and elevates reliability practices. To learn more, you can watch this presentation at InfoQ Dev Summit Boston 2025: Fix SLO Breaches Before They Repeat to see a demo.

Modernizing Spring Boot + Azure Cosmos DB with GitHub Copilot

A standout moment was the Reactor session on modernizing Spring Boot apps from relational databases to Azure Cosmos DB, using GitHub Copilot to accelerate every step. This presentation also demonstrates features in Visual Studio Code with GitHub Copilot for customizing agentic AI instructions and prompts.

Developers learned how Copilot can:

• Identify relational data access code
• Generate Cosmos DB‑compatible repositories, entity models, partitioning annotations
• Apply schema reasoning using AI
• Create migration tasks and unit tests automatically
• Validate migration paths from local dev to cloud deployment

This brings database modernization into the same workflow as app upgrades—critical for Java cloud migrations. Watch the replay on the Microsoft Reactor page. For more on context engineering and custom instructions, you can also watch this other presentation Context Engineering for Java Ecosystem.

AI and Java for Beginners

Experts are pushing the boundaries of AI development, whether with AI assisting tools, with Agentic AI coding, or building custom Agents. But we must start somewhere, and for beginners, it is important to have fundamentals and basic understanding of core tools. This is why the Microsoft Developer Relations team for Java, built and published the Java and AI for beginners series.

We help you through foundational ideas first and then move into hands-on examples:

• Getting started fast– Spin up your first AI-powered app using GitHub Codespaces.
• Core generative AI techniques– Learn the basics behind completions and chat flows. See how function calling connects models to real tools and services. Get an introduction to Retrieval-Augmented Generation (RAG) for document-aware applications.
• Simple, focused application– Explore small projects that illustrate different capabilities, such as combining text and image generation, running models locally with the Azure AI Foundry Local experience, and wiring tools with the Model Context Protocol (MCP).
• Responsible AI– Apply safety features from GitHub Models and Azure services. We cover content filtering, bias awareness, and practical checks you can add before deployment.
• MCP in Java– Understand the Model Context Protocol and how it fits Java workflows. Learn what it means to implement an MCP server, connect a Java client, and use tools through a consistent protocol.
• Context engineering for Java– Improve results with clean prompts, structured context, and simple evaluation steps. We discuss when to persist context and when to compute it on the fly.
• Modernization with AI assistance– See how the GitHub Copilot App Modernization experience helps upgrade and migrate Java applications. Then follow a guided flow to deploy to Azure with AI-assisted configuration.
• LangChain4j essentials– Start a basic project that targets OpenAI-compatible endpoints, then build a small agent with tools and memory to understand the moving parts.
• Running GenAI in containers– Review when to use on-demand GPUs for inference and training. Learn how dynamic sessions in Azure Container Apps support code interpreters and short-lived, cost-aware execution.

Each video is short and focused. Watch them in order if you are new to the space or skip into the topics that match your immediate needs.

Developer Voice: Microsoft JDConf, JavaOne 2025

The year was full in terms of sharing ideas. Everyone had something to say, especially about AI. Of course, Microsoft also had a few ideas to share, and that is why we were present at dozens of conferences in 2025, all around the world: DevNexus, Devoxx, JavaLand, JavaOne, JavaZone, SpringOne, and others.

Meeting other developers at conferences, whether virtual or in-person, remain one of the best ways to share ideas and learn from others. This year, we gave continuity with our own space, Microsoft JDConf, so Microsoft experts and community speakers could participate and share theirs. In addition to that, we participated in key events like Oracle’s flagship Java developer conference, JavaOne. In 2026, we will be there again.

Microsoft JDConf

The 2025 edition focused on our opportunity to Code the Future with AI. There were 22 technical sessions across Spring, Quarkus, AI agentic development, core Java principles, modern tooling, and code modernization. With strong global community engagement and the presence of luminaries and Java Champions like Josh Long and Lize Raes, JDConf 2025 was a milestone for our community engagement, giving them the space and amplification to share their ideas. Watch the recordings.

For 2026, we are excited for what’s to come! Microsoft JDConf call for papers is up and running, and the conference will be back on April 8-9 with the usual three timezones live streams so everyone can engage and learn.

JavaOne

This year we were at Oracle’s JavaOne conference where we shared what developers can get with Microsoft tools and services for modern Java development with AI. We also had exciting breakout sessions on AI, modernization, and cloud-native Java, where thousands of developers engaged in person and online. Needless to say, we will be back at JavaOne 2026, so stay tuned!

In the meantime, watch again the Microsoft keynote at JavaOne 2025 and our two breakout sessions, Next-Level AI Mastery for Java Developers, and From RAG to Enterprise AI Agents: Building Intelligent Java Apps.

Open Source Contributions

Microsoft teams continued collaborating with key projects in the Java ecosystem. A few highlights go to OpenJDK contributions by Microsoft’s Java Engineering Group, and contributions by the Microsoft Developer Relations team to frameworks like Spring AI, Quarkus, and LangChain4j.

LangChain4j has become a de facto standard in building intelligent Java applications, and integrations with Microsoft AI services are key for enabling customers to leverage the latest AI models and capabilities into their systems. To learn more about LangChain4j and our contributions to it, check out the blog Microsoft and LangChain4j: A Partnership for Secure, Enterprise-Grade Java AI Applications.

The Road Ahead — 2026 and Beyond

With OpenJDK 25 now the active LTS, the ecosystem is entering a new multi‑year cycle. Microsoft will continue investing in:

• Deeper GitHub Copilot agent workflows
• Adaptive JVM tuning intelligence
• Expanded modernization formulas
• Broader Azure service integrations
• Next‑gen Spring, Quarkus, LangChain4j, & Java AI tooling

The mission remains unchanged: empower every Java developer to build intelligent applications, modernize legacy codebases, and operate applications with world‑class tooling, AI assistance, and cloud‑native excellence.

The post Java at Microsoft: 2025 Year in Review appeared first on Microsoft for Java Developers.