June 2026 Summaries

Kotlin celebrated its 15th anniversary with a flurry of updates and announcements, including the release of Kotlin 2.4.0, which introduces new features such as stabilized context parameters and expanded standard library capabilities across multiple platforms. The Kotlin Toolchain 0.11 offers a streamlined workflow for project management, while Koog 1.0 reaches a significant milestone for building AI agents in Kotlin. The Kotlin Foundation is offering grants for developers working on open-source projects, and Compose Hot Reload and Multiplatform updates are pushing boundaries in UI development and AI interaction. Notable stories include Booking.com's successful adoption of Kotlin Multiplatform and Sony's long-term satisfaction with their Kotlin Multiplatform efforts, highlighting the language's versatility and growing ecosystem. Additionally, free Kotlin courses are available on Hyperskill, providing opportunities for developers to enhance their skills in celebration of the language's milestone anniversary.

The integration of GitHub Copilot into JetBrains IDEs as a native agent enhances the development experience by providing a more stable and readily available tool within the existing environment. Previously accessible via the ACP Registry, this collaboration between JetBrains and GitHub ensures a seamless setup, enabling developers to focus more on building rather than configuration. Users can access Copilot's features, such as CLI slash commands, directly in AI chat, and authentication is managed through OAuth with a separate GitHub Copilot subscription required. The integration promises ongoing improvements, and users can start by selecting GitHub Copilot in the agent picker menu of their JetBrains IDE and following the OAuth login process to connect their GitHub account.

JetBrains Air has expanded its accessibility to Windows developers, responding to a high demand from the developer community for Windows support. This platform is designed for agent-agnostic development, allowing users to utilize AI coding agents to implement features, fix bugs, and review code within a dedicated environment. With the release for Windows, developers can integrate Air into their daily workflows, using its desktop app as a bridge between terminal operations and full integrated development environments (IDEs). It supports multiple development workflows, such as running agents in parallel in separate Git worktrees, allowing changes to remain independent, and facilitating code reviews by using different agents. The platform emphasizes better context for improved output and has been enhanced for stability to provide Windows developers with a seamless experience from the outset.

In the face of rising financial breach costs and evolving attack vectors, static code analysis has become crucial for fintech compliance, automating consistent code reviews and generating audit artifacts within the CI/CD pipeline. The text highlights that while frameworks like PCI DSS, SOC 2, NIST SSDF, and ISO 27001 emphasize the importance of evidence-backed secure coding processes, they don't specify tools, leaving room for static analysis to support compliance through systematic vulnerability detection and policy enforcement across all code changes. By catching issues early, static code analysis reduces security debt, aids in compliance by creating a traceable audit trail, and integrates seamlessly with CI/CD processes, ensuring that every code change is scrutinized against security standards. Despite its strengths, static analysis is not a standalone solution; it complements other security measures such as Software Composition Analysis (SCA), Dynamic Application Security Testing (DAST), and manual reviews to provide a comprehensive security posture. Qodana, highlighted as an example, integrates JetBrains IDE checks into the CI/CD workflow, helping fintech teams enhance code quality and compliance, thereby supporting a repeatable and auditable engineering process.

JetBrains has announced that starting with IntelliJ IDEA version 2026.2, Kotlin Notebook will be sunsetted as a product and will no longer be maintained internally, transitioning instead to an open-source model for community development. This decision comes in response to evolving demands for interactive tooling and the impact of AI tools on development workflows, as Kotlin Notebook did not achieve the expected adoption levels. Although JetBrains will unbundle Kotlin Notebook from future IntelliJ IDEA releases, the plugin will remain available on GitHub under the Apache License 2.0, where users can continue its development. JetBrains will continue to support the Kotlin Jupyter kernel on a best-effort basis during the transition, and encourages community involvement through the Kotlin Slack channel. Meanwhile, Kotlin DataFrame will continue to be developed, offering easier integration of notebook-style data transformations into regular Kotlin projects, with recent updates enhancing its functionality in Gradle and Maven environments.

IntelliJ IDEA is set to open-source its Language Server Protocol (LSP) client API in the 2026.2 release cycle, addressing issues faced by plugin authors who previously had to create custom solutions due to the lack of a unified open-source LSP client. This initiative aims to enhance integration across JetBrains IDEs, Android Studio, and other products built on the IntelliJ Open Source project by providing a stable and battle-tested platform client. The API will undergo a renaming process to eliminate confusion between client and server roles, with the changes anticipated to be available by the 2026.1.4 stable build. The collaboration between JetBrains and Google may lead to Android Studio support arriving sooner than the 2026.2 release. Plugin developers are encouraged to monitor updates, adapt to new API names, and consider the LSP article in the IntelliJ Platform SDK Docs for new language integrations while using available tools like the IntelliJ Platform Plugin generator for plugin development.

Python 3.15 introduces explicit lazy imports via PEP 810, a feature that defers module loading until their attributes are first accessed, aiming to reduce startup latency and memory consumption significantly. This approach uses proxy objects within the module’s namespace, preserving critical interpreter optimizations while maximizing efficiency, particularly in environments with high-latency filesystems. Python 3.15.0b1 is available for testing, and users can try this feature using tools like `uv` or `pyenv` to download the beta version. Profiling scripts with lazy imports shows a decrease in loading time, as unnecessary modules like pandas are not loaded until used, enhancing performance in scenarios where large libraries are only conditionally required. The internal mechanism involves lazy objects being reified upon use, with modules moving from `sys.lazy_modules` to `sys.modules` only when accessed, thus avoiding unnecessary imports. Users can experiment with this feature in PyCharm, although full support for Python 3.15 is still in development.

Membership inference attacks pose a significant threat to user privacy by exploiting machine learning models, particularly large language models (LLMs), to determine if specific data points were used during training without directly accessing the data. These attacks can reveal sensitive information, particularly in fine-tuned models, which are more vulnerable due to their smaller datasets and stronger memorization. The post by JetBrains researchers highlights the underestimated risk of these attacks and critiques current detection methods as inadequate. They introduce a new attack method called Error Zone Membership Inference Attack (EZ MIA), which focuses on the model's mistakes to detect membership signals more effectively than traditional methods. This approach requires fewer resources and offers a practical way to assess privacy risks in fine-tuned language models, particularly in differentiating between full and parameter-efficient fine-tuning like Low-Rank Adaptation (LoRA). The findings underscore the need for precise privacy auditing tools to prevent unintentional data exposure in LLMs, advocating for more focused research on privacy risks associated with fine-tuning practices.

With the modern shift towards isolated environments for development, IntelliJ Platform introduced EelApi, an API designed to aid plugin authors in managing projects hosted in environments like WSL or Dev Containers. Traditionally, IDEs and project files coexisted on the same machine, but newer setups often separate them, necessitating more precise handling of paths, processes, and environment variables. EelApi addresses these challenges by providing tools for environment-aware file operations, process executions, and networking, allowing plugins to interact seamlessly with execution environments distinct from the local machine. Initially tested with WSL, EelApi has been extended to support Dev Containers, enabling native integration where projects can be managed locally without full IDE backends in containers. Although still marked as experimental, EelApi is poised to evolve, with plans for stabilization, documentation, and broader adoption across IntelliJ-based IDEs, aiming to minimize the distinctions between local, WSL, and containerized projects for plugin developers.

JetBrains AI has introduced Codex as the recommended agent for coding tasks within its IDEs, following a comprehensive evaluation of multiple agents like Codex, Junie, and Claude Agent. This decision was based on a detailed assessment using a benchmark dataset that included real-world software engineering tasks across Java, C#, and Python ecosystems, focusing on three main criteria: solve rate, cost, and latency. Codex, particularly its GPT-5.4-mini model with medium reasoning, outperformed other candidates by achieving the best combination of solve rate and cost-effectiveness, despite having a higher latency in some cases. The evaluation also included an online A/B test with real users to confirm these findings in practical scenarios. The aim is to provide an agent that integrates seamlessly into developers' workflows, although users retain the flexibility to switch to other agents as their needs evolve. As the landscape of AI models and agents continues to develop, JetBrains plans to revisit and potentially update their recommendations based on new data and advancements.

JetBrains has introduced a significant update in its Toolbox App 3.6 Early Access Program (EAP) by transitioning SSH connections to remote environments to the JetBrains Daemon (jetbrainsd) by default. This change aims to enhance the reliability of remote development flows and reduce dependence on the Toolbox-App-specific implementation, with jetbrainsd becoming a shared background service for JetBrains tools. Users are encouraged to try the EAP build and report any issues through YouTrack, attaching Toolbox App logs to assist in identifying problems, whether related to daemon startup, security policies, authentication, or SSH connections. Temporary workarounds are available, including disabling the jetbrainsd SSH client or reverting to the latest stable Toolbox App version, to maintain flexibility and gather user feedback during this validation phase.

SpaceX's $60 billion acquisition of Cursor's parent company, Anysphere, highlights a shift in software engineering priorities from sheer code generation to ensuring code quality, as AI dramatically increases the volume of code being produced. While AI tools like Cursor, JetBrains AI, and GitHub Copilot enhance productivity by rapidly generating code, they also necessitate rigorous verification processes to maintain code integrity, security, and maintainability. This transformation in the software landscape emphasizes the importance of automated quality analysis and layered workflows, where AI-generated code is validated through static analysis and quality gates, allowing human reviewers to focus on strategic decisions. Academic research supports this nuanced relationship between AI and productivity, pointing out that while AI increases development speed, it also introduces complexities that can slow long-term progress if not adequately addressed. Tools like Qodana aim to complement AI by automatically inspecting code for quality issues, helping teams produce reliable and compliant code without discarding AI's benefits.

JetBrains' Rider has introduced a new dotTrace-backed profiling skill for its AI Assistant to address the limitations of AI agents in identifying performance bottlenecks in applications. Traditionally, AI agents have struggled to accurately diagnose issues like app freezes by merely scanning code and making educated guesses, often missing the real problem. The new skill allows agents to analyze .dtp snapshots captured with dotTrace, providing precise runtime evidence to pinpoint CPU usage and inefficiencies. The implementation has significantly improved the accuracy of diagnosing performance issues, as evidenced by evaluations that showed a leap in average accuracy scores from 4.71 to 8.15 out of 10 and a doubling in perfect root-cause matches. While the enhanced accuracy comes at a slightly higher cost per run, the skill reduces time and expenses by focusing on evidence rather than speculative code analysis. This feature, available in the Rider 2026.2 EAP, bridges the gap between code analysis and runtime evidence, transforming the AI Assistant from an agent that guesses to one that knows.

Rust web development, as discussed by Mateusz Maćkowski and Marek Grzelak, remains a complex ecosystem that emphasizes safety and performance but poses several challenges before code hits compilation. The development process in Rust involves selecting from a fragmented ecosystem of libraries, handling intricate async programming models, and managing manual database schema maintenance across multiple layers. The debugging experience in Rust, especially with async functions, can be cumbersome due to extensive backtraces and the need to understand concepts like pinning and tasks versus threads. Error handling is inconsistent across web frameworks, and the use of macros, while powerful, can lead to opaque code and challenging error resolution. Compile times are a notable bottleneck in the development cycle, exacerbated by generics, macros, and large dependency trees. Despite these hurdles, initiatives like cot.rs and Loco.rs are emerging to provide more integrated solutions, though Rust still lacks a dominant, batteries-included framework akin to Django or Rails. While Rust's robustness makes it suitable for projects prioritizing performance and reliability, it demands a steeper learning curve and slower iteration pace compared to languages like Python, making it less ideal for rapid development of simple applications.

YouTrack 2026.2 introduces several enhancements, including the ability to organize B2B support via customer groups in YouTrack Helpdesk. This update allows support teams to manage tickets by company or organization, tailor SLAs, and assign specific agents to customer groups, improving the support experience for both agents and customers. Whiteboards now feature auto-layout and interactive widgets for better project visualization, while redesigned Gantt charts enhance project planning and tracking. The release also simplifies connecting AI tools using the Model Context Protocol (MCP) without needing permanent tokens, allowing for seamless integration of AI workflows into YouTrack. Additionally, the update offers new import options from platforms like ClickUp and Asana, and expands functionality with new apps from JetBrains Marketplace, improving task management, testing, and time tracking capabilities. These improvements aim to streamline project management and support processes, making YouTrack a more efficient tool for teams.

Amper has evolved into the Kotlin Toolchain, now in its Alpha stage, offering a unified entry point for Kotlin development with features like publishing JVM libraries, new plugin development APIs, and improved developer experiences. The transition integrates Amper's previous capabilities into a single command, "kotlin," facilitating project creation, building, testing, and publishing. The Kotlin Toolchain allows for global installation, enhancing convenience for developers using various directories and offering project-agnostic commands. It supports JVM library publication to Maven repositories, including Maven Central, and introduces cinterop support for generating custom bindings for C libraries. The toolchain's IDE plugin requires installation in IntelliJ IDEA, replacing the former Amper plugin, and offers improvements in terminal UI, module-wide dependency resolution, and plugin development. The release introduces features like custom checks and commands, a new way to register generated files, and improved run command experiences. With updated default versions for various toolchains and frameworks, developers are encouraged to provide feedback to help shape the future of the Kotlin Toolchain.

The AWS Image Builder Plugin for TeamCity simplifies the maintenance of cloud build agents by automating the creation and updating of Amazon Machine Images (AMIs), essential for ensuring the efficient operation of TeamCity's CI/CD process. Traditionally, maintaining these agents involves manually updating static machine images and dealing with issues such as obsolete repositories and lengthy source pulling times. The plugin integrates seamlessly with TeamCity, enabling users to automate AMI updates via build configurations, reducing manual intervention and ensuring that agents are always up-to-date. It allows pre-populating images with Git object mirrors to expedite the build checkout phase, and the plugin also supports AMI selection by tags, ensuring that the most recent images are used automatically. This automation reduces downtime and maintenance efforts, allowing developers to focus more on build processes while minimizing the need for manual image updates.

PHP version migration is a challenging yet crucial task for development teams, particularly as nearly 72% of websites rely on PHP, with many still using outdated versions like PHP 7, which poses security risks. Migrating to newer versions like PHP 8 can result in significant performance improvements, but teams often face hurdles such as hidden incompatibilities in large codebases, deprecated functions, and the competition between migration and new feature development. JetBrains' Qodana, a smart static analyzer, addresses these issues by providing a comprehensive analysis of code incompatibilities before migration begins, giving teams a clearer understanding of deprecated functions, their usage, and the criticality of each issue. This tool enhances the migration process by allowing teams to estimate work scope accurately, fix blockers pre-deployment, and avoid manual audits, ensuring a smoother transition and preventing regressions in the CI pipeline. Integrating Qodana with PhpStorm further simplifies the remediation of migration issues and enforces quality checks before release, offering a proactive approach to managing migration risks.

During the JetBrains x Codex Hackathon, Katherine Druckman observed that the key to winning was not merely the work done over 24 hours but how effectively teams presented their projects. Judges emphasized starting with a clear articulation of the problem being solved and ensuring the demo is straightforward and engaging. Jono Bacon and Avi Press highlighted the importance of making the problem relatable to the judges, while Bonnie Xu advised focusing on building solutions to specific annoyances rather than chasing new technologies. Preparation is crucial, as Jan-Niklas Wortmann and Colin Lowenberg advised understanding the hackathon's objectives and leveraging familiar tools to minimize unknowns. The best projects focus on delivering one well-executed feature rather than multiple half-baked ones, making the demo the center of the pitch. Rehearsing the presentation and ensuring the demo runs smoothly are essential, as Colin suggests visualizing success and working backward from there. Ultimately, the most successful teams are those that convey genuine enthusiasm for their projects, as this passion resonates with judges and enhances the overall presentation.

JetBrains has developed an ROI calculator to help organizations estimate the potential financial and productivity gains from investing in their IDEs and AI Ultimate subscriptions. The calculator's projections are based on a model that combines user inputs, internal research, and assumptions regarding developer workflows, with data drawn from sources such as the JetBrains State of Developer Ecosystem Survey and custom productivity surveys. These surveys focus on different developer workflows, including managed languages and system languages, and are designed to assess the time saved by using JetBrains tools compared to previous solutions. The findings are used to estimate productivity improvements, which are then applied to calculate productivity boosts in relation to the time developers spend in their IDEs and AI-related tasks. The ROI is calculated by comparing the productivity savings against the pre-tax cost of licenses, providing a conservative yet realistic estimate of potential benefits. However, these estimates are illustrative and not guaranteed, as they rely on average benchmarks and self-reported data, which may not accurately reflect every organization's unique circumstances.

With the impending end of life for Atlassian's Bamboo Data Center, teams are encouraged to reevaluate their CI/CD processes rather than simply replacing Bamboo with another tool. The guide suggests starting with an audit of current configurations to identify business-critical pipelines and eliminate outdated workflows, thereby avoiding the migration of technical debt. It shares the example of Keylane, a company that rebuilt its CI/CD pipelines using TeamCity's Kotlin DSL, achieving significant improvements in build speed. The text also outlines considerations for choosing a Bamboo replacement, such as scalability, hosting flexibility, and integration capabilities, highlighting options like Bitbucket Pipelines, GitHub Actions, GitLab CI/CD, Jenkins, and TeamCity. The migration process is recommended to be iterative, allowing teams to run old and new systems in parallel to refine workflows and ensure a smooth transition. Ultimately, the focus should be on creating a more maintainable and efficient delivery platform that aligns with the team's future needs.

YouTrack administrators are being advised to upgrade their YouTrack Server installations to address several security vulnerabilities identified in versions prior to 2024.2, with fixed builds now available starting from this version. While YouTrack Cloud users have already received patches and require no further action, YouTrack Server users are urged to upgrade to versions 2026.1.13757, 2025.3.148033, 2025.2.148048, 2025.1.148120, 2024.3.148430, or 2024.2.148429 to mitigate risks, such as admin account takeover through authentication token forgery or email verification bypasses. These vulnerabilities, discovered via coordinated disclosure and AI-assisted security research, have not been exploited outside of testing environments, but JetBrains recommends prompt upgrading to ensure protection. For further assistance, users are encouraged to consult the Installation and Upgrade documentation or contact YouTrack Support.

The text discusses the implementation of Plugin Model v2, an experimental method for structuring, packaging, and building IntelliJ plugins to support optional content modules that load based on available IDE functionality. It uses CSS PSI-related functionality as an example, highlighting how it can be integrated as an optional module in a plugin, contingent on the presence of a bundled IDE plugin content module. The narrative explains the process of using the IntelliJ Platform Gradle Plugin to manage dependencies and configure modular builds, emphasizing the flexibility and future-proofing of plugins as they adapt to different IDE versions. The example demonstrates optional functionality where CSS action can access CSS PSI based on subscription status, showing the model's adaptability to both current (IntelliJ IDEA 2025.3) and upcoming (IntelliJ IDEA 2026.1) IDE versions. The document concludes by suggesting that optional plugin content modules allow for isolating platform-specific features, and it encourages further exploration of multi-module configurations and remote development readiness.

JetBrains' Qodana has been recognized as a finalist in the 2026 CODiE Awards for Best DevOps Tool in Developer and AI Technology, reflecting its impact on enhancing code quality and security in DevOps environments. It automates quality and security checks across the CI/CD pipeline, allowing teams to build more secure and high-quality software while maintaining speed and efficiency. By integrating deeply into existing workflows, Qodana provides fast, actionable feedback directly within pull requests and IDEs, reducing manual review efforts and preventing issues before they reach production. Its features include extensive static analysis, customizable inspections, organization-level dashboards, and comprehensive integration capabilities. Qodana supports a wide range of IDEs and CI systems, offers both cloud and self-hosted options, and emphasizes security and compliance with built-in tools for vulnerability scanning and license auditing. The platform's scalability and storage solutions ensure that as organizations grow, they can maintain consistent quality and security standards, ultimately empowering DevOps teams to ship software with greater confidence and control.

JetBrains has launched Junie, an AI coding agent, out of its beta phase, emphasizing its seamless integration into the developer workflow within JetBrains IDEs and the terminal. Junie distinguishes itself by planning before coding, debugging with a real debugger rather than relying on log statements, and offering a comprehensive code review process that maintains project context. It supports flexibility by allowing developers to choose models based on cost and performance needs, connecting to both frontier labs and local runtimes. Key features include an advanced Plan mode that encourages structured project planning, agent-driven debugging, remote task management, and deep IDE integration, which includes database connectivity and leveraging existing IDE tools. Junie aims to be a dependable tool, enabling developers to delegate tasks confidently and efficiently, and is available to users with a JetBrains AI subscription or through local model runtime connections.

Step Rejection Fine-Tuning (SRFT) is a novel approach developed by JetBrains Research to enhance the training of large language model (LLM) agents by leveraging unsuccessful trajectories, which are traditionally discarded in standard practices like Rejection-sampling Fine-Tuning (RFT). The method involves using a "critic" model to analyze training data and identify specific steps within failed attempts that are either productive or harmful, allowing the model to learn from the useful actions while ignoring the mistakes. This approach addresses the inefficiency of discarding entire runs due to final outcome failures, as research shows that even unsuccessful trajectories contain a significant amount of correct and valuable steps. Results from experiments using the SWE-smith and SWE-bench datasets demonstrate that SRFT improves model performance by selectively masking loss calculation on erroneous steps, thus extracting the beneficial elements of failed trajectories without reinforcing errors. This technique, while straightforward and cost-effective, requires careful tuning of the critic's strictness to maximize its effectiveness, making it a promising strategy for optimizing agent training outcomes.

JetBrains has partnered with LinkedIn to enable developers to showcase their expertise with JetBrains IDEs directly on their LinkedIn profiles through a new connected apps feature. This integration allows users to install a free plugin that connects their IDE, such as IntelliJ IDEA, PyCharm, or WebStorm, to LinkedIn, providing a visible and credible display of their practical tool usage, which updates automatically as their experience evolves. The current release supports several JetBrains IDEs, with plans to include DataGrip in the future, and aims to reflect real-world usage rather than act as a certification. This initiative is part of LinkedIn's broader strategy to allow users to feature real-world product usage on their profiles, thereby enhancing professional visibility and credibility.

On June 16, 2026, JetBrains identified a security breach involving 15 third-party plugins on its Marketplace, which were designed to steal AI provider API keys by masquerading as legitimate utilities. In response, the company removed the malicious plugins, banned the associated publisher accounts, and activated a remote mechanism to disable the plugins in users' IDEs. Despite the breach, JetBrains confirmed that its core systems remained uncompromised. The threat actors exploited a specific vulnerability by disabling TLS warnings and exfiltrating API keys to a hardcoded IP address. In the aftermath, JetBrains emphasized the importance of security diligence, instructed affected users to revoke exposed API keys, and introduced new security measures to prevent similar incidents. The company is advocating for the adoption of the Agent Client Protocol (ACP) registry to enhance security in AI workflows by standardizing communication between IDEs and external tools.

In the wake of the U.S. government's intervention to restrict access to Anthropic's AI models due to security concerns, a broader issue emerges about the AI industry's preparedness for a future where trust, provenance, and safeguards are as crucial as performance. The debate over government overreach versus necessary security measures overlooks the need for the AI field to ensure transparency and accountability in model behavior. As AI systems increasingly take on critical tasks in various sectors, the focus shifts from model capabilities to understanding how and why models operate, emphasizing the importance of continuous verification and robust oversight. This shift mirrors lessons from the software industry, where provenance and security have become essential to prevent vulnerabilities and exploits. The Anthropic case underscores the fragility of relying on static trust assumptions and highlights the necessity for dynamic monitoring and governance to responsibly scale AI deployment. The future success in AI will depend not just on innovation but on the ability to verify and maintain trust through stronger provenance mechanisms, continuous monitoring, and transparent safeguards.

JetPride, an employee-led LGBTQIA+ community at JetBrains, was established to provide a supportive space for LGBTQIA+ employees and allies, fostering connections across different teams and locations. The group encourages open dialogue, curiosity, and mutual respect, with activities like Pride Month events that celebrate diversity and promote understanding through conversations and shared experiences. This year's theme, "Growing with Pride," emphasizes the gradual development of understanding and features visual elements inspired by various Pride flags, symbolizing the spectrum of identities within the LGBTQIA+ community. Pride Month at JetBrains includes diverse activities tailored to local interests, such as talks, film screenings, and informal gatherings, illustrating the company's culture of employee-driven initiatives and community building. Through JetPride, employees contribute not only in their professional roles but also in shaping inclusive and meaningful experiences at the workplace.

dotInsights by JetBrains is a newsletter dedicated to sharing the latest updates and insights from the .NET and software development communities. The newsletter covers a range of topics including performance profiling, JSON source generation, single sign-on setup, and observability tools, alongside discussions on software design principles like DRY and abstraction budgeting. It also highlights advancements in .NET, such as improved query performance in EF Core 11, pattern matching in C#, and the introduction of Corvus.Text.Json V5. Additionally, JetBrains news focuses on the 2026.2 Early Access Preview, which features innovations like AI agent skills for test generation and a redesigned NuGet tool window, as well as improvements in accessibility and new project templates for game development. The newsletter encourages readers to engage with the content by downloading Early Access Previews and providing feedback.

In 2026, Python remains the leading language for AI and machine learning development, supported by a robust ecosystem of frameworks tailored for various tasks. Deep learning frameworks like TensorFlow and PyTorch excel in neural networks and GPU acceleration, essential for processing images, text, and audio, while scikit-learn and XGBoost offer powerful tools for classical and tabular machine learning, ideal for structured data. LangChain and Hugging Face serve the growing demand for large language model applications, offering specialized tools for AI agents and natural language processing. Frameworks like Keras provide user-friendly APIs for rapid experimentation, whereas TensorFlow's comprehensive deployment ecosystem supports large-scale production. PyTorch, known for its flexibility and Pythonic design, dominates in research settings. Open-source frameworks are favored for their transparency, community support, and lack of vendor lock-in, although commercial AI platforms provide managed infrastructure and enterprise features. The choice of framework depends on project requirements, data types, and deployment needs, with many teams utilizing a combination of frameworks to optimize their AI development processes.

The PHP Foundation, in collaboration with Dominika Stankiewicz, is conducting the first annual State of PHP survey to gather insights into the global PHP developer community. This comprehensive survey aims to explore various aspects of PHP development, including developer experience, preferred frameworks, and AI preferences, with the ultimate goal of creating a representative overview of the PHP ecosystem. Participation from a diverse range of PHP developers is encouraged to ensure the survey's success, and those who take part have a chance to win a EUR 500 voucher. The findings from this initiative will be published in the State of PHP 2026 report, offering valuable insights to help shape the future of PHP development. Participants can stay updated on the progress and results through the PHP Foundation and PhpStorm's communication channels.

The release candidate for MPS 2026.1 introduces a significant new feature, making the platform accessible to AI coding agents through the Model Context Protocol (MCP) via the Projectional Agent Toolkit plugin. This experimental feature allows users to enable an MCP server within MPS, facilitating seamless integration with MCP-capable agents and automatically displaying toolsets and skills. While the Projectional Agent Toolkit is subject to potential API changes, users can refer to its documentation for comprehensive details. Additional updates and a comprehensive list of fixed issues from earlier builds are available for review, providing a thorough preview of the enhancements in the upcoming release.

Agentic AI governance requires designing accountability and control into AI systems from the outset, emphasizing structured permissions, boundaries, monitoring, and traceability to ensure trust and operational control within organizations. Instead of focusing on blame after failures, organizations should integrate governance as a core feature in their AI workflows, treating AI agents like new hires by granting autonomy incrementally and maintaining clear accountability over outcomes. Essential governance practices include defining boundary conditions to prevent over-permissioning, creating meaningful audit trails due to the non-deterministic nature of LLM-based agents, and maintaining human oversight in strategic decision-making to mitigate risks. JetBrains Central exemplifies this approach by embedding governance into development infrastructure, encouraging isolation of AI agents to confine potential damage, and providing contractual and technical assurances for accountability when issues arise. By treating governance as an integral part of architecture and workflows, organizations can confidently expand AI capabilities, knowing responsibility is clearly defined and systems operate within established policies.

Modern C++ features such as compile-time computation and template code are increasingly accessible, but their productivity hinges on effective tooling, which the CLion language engine aims to provide. Recent updates in CLion, particularly in version 2026.1 and beyond, enhance support for C++26 features, excluding reflection, and offer innovative improvements like the #embed preprocessor directive and pack indexing. The newly introduced Constexpr Debugger enables developers to step through compile-time evaluations, simplifying the debugging of constexpr and consteval code. Additional updates include support for GCC and Clang extensions, improved code assistance, and refactoring features, such as automatic import for C++20 modules and inspections that detect common coding mistakes. These enhancements, powered by the CLion Nova engine, aim to streamline the development process by reducing manual tasks and improving code clarity, making it easier for developers to leverage modern C++ capabilities efficiently.

The text delves into the intricacies of C++ resource management, highlighting the importance of the Rules of Zero, Three, and Five, which are guidelines for handling special member functions to prevent common bugs like double-frees and dangling pointers. It explains how these rules guide developers in managing object copying and destruction, emphasizing practices such as using smart pointers like `unique_ptr` to simplify memory management and the copy-and-swap idiom to prevent self-assignment errors. The discussion is complemented by insights from Anna Zhukova, a software developer specializing in static analysis tools like Qodana for C++, which integrates with Clang-Tidy to enforce these rules and detect related issues at the commit stage. The text underscores the role of static analysis in catching bugs early and improving code quality, while also acknowledging the performance considerations of certain idioms, such as copy-and-swap.

Plugin Developer Conf 2026, a free online community event organized by JetBrains, is scheduled for November 10, 2026, focusing on the development and management of plugins for JetBrains products. This conference aims to unite experts and practitioners to share knowledge, experiences, and insights on various topics such as plugin testing, localization, user feedback management, and scaling projects, benefiting developers at different stages of their journey. The event encourages interactive participation, having successfully engaged over two thousand developers in the previous year. The organizers are currently seeking speakers to contribute talks on topics like plugin creation, marketing, and technical challenges, with submissions open until July 20, 2026. Selected speakers will receive a complimentary one-year JetBrains All Products Pack subscription and support for their presentation preparations.

RustRover 2026.2 addresses the issue of false positives in the Integrated Development Environment (IDE) by reducing them by up to 25% based on real project data. False positives, which occur when the IDE incorrectly identifies errors in code that compiles successfully, disrupt the development flow. RustRover uses both cargo check and its own analysis engine to detect issues, but discrepancies can lead to false positives. This independent analysis engine is essential for IDE features like code completion and navigation, which require a deep understanding of code beyond what compilers provide. To improve accuracy, RustRover conducts large-scale analysis on open-source crates and leverages user feedback and anonymous statistics to identify and fix false positives. The dedicated task force assembled after the 2025.2 release focuses on these improvements, aiming to enhance the reliability of IDE diagnostics, thereby allowing developers to concentrate on writing Rust code. Users are encouraged to report any false positives to aid in the ongoing refinement of RustRover’s code insight capabilities.

Rider 2026.2 EAP 5 introduces several enhancements aimed at improving AI-assisted development, including a new non-modal Welcome screen for a faster startup and bundled quality-check hooks for AI agents like Claude Code and Codex. These hooks, specifically PostToolUse, ensure that agent-generated code undergoes IDE-level validation to detect issues and formatting inconsistencies before proceeding, thus raising the quality bar set by the IDE itself rather than the AI agent. Additionally, the update makes the "Explain with AI" feature more accessible, allowing .NET developers to receive clearer explanations of build errors and runtime exceptions directly from the IDE, transforming complex diagnostics into understandable insights for quicker resolution. This development cycle encourages users to explore and give feedback on how these new features enhance their projects.

Zig, a programming language created by Andrew Kelley, has taken an unconventional approach by deliberately delaying its 1.0 release, focusing instead on perfecting its fundamentals before committing to backward compatibility. Unlike many languages that rush to a stable version to signal maturity and encourage adoption, Zig's development is driven by a small, independent team under a nonprofit foundation, allowing it to prioritize long-term design integrity over immediate growth. This patient strategy reflects a broader philosophy of avoiding unnecessary complexity to prevent future design debt, challenging traditional notions of when a technology is truly "ready." Although a 1.0 release would likely increase Zig's adoption, the project remains committed to its careful approach, raising questions about the true meaning of readiness in technology.

The June 2026 edition of Java Annotated Monthly offers an extensive overview of the latest advancements and discussions in the software development world, focusing on Java, Kotlin, AI, and other emerging technologies. This issue features a variety of content, including updates on Java Development Kits, structured concurrency, and new features in Java 26, as well as tutorials, tips, and podcasts on Java's security and memory efficiency. The Kotlin segment highlights recent developments like Koog 1.0 and official support for Visual Studio. The AI section delves into the impact of AI on coding and enterprise Java teams, while the broader technology section covers updates in frameworks like Spring and Micronaut, and explores topics such as Kubernetes and platform engineering. Additionally, the issue lists several upcoming conferences and events and includes cultural insights into the developer community. The publication concludes with a call for suggestions for future editions and an invitation to explore their archive.

IntelliJ IDEA 2026.1.3 has been released with several updates and improvements, such as resolving the issue of the terminal cursor being rendered above the current line in tmux, ensuring the Markdown preview correctly displays images outside the project directory, and properly rendering custom colors in the Database tool window's UI components. Additionally, the update addresses shell integration and process detection issues when launching WSL via wsl.exe. Users can update to this version through the IDE, the Toolbox App, or snaps for Ubuntu users, and can also download it from the official website. For a detailed list of fixes, users are directed to the release notes, and feedback on any issues can be submitted through the issue tracker.

RustWeek 2026 in Utrecht, Netherlands, gathered over 900 Rust developers, educators, and maintainers for a multifaceted event featuring talks, hackathons, and workshops focused on the Rust programming language. The RustRover team, as a Gold sponsor, participated actively by engaging with attendees, sharing updates on their tools, and conducting interviews to capture diverse perspectives on Rust's future. Key themes included the growing interest in embedded Rust, professional adoption of Rust, and its integration into existing workflows. Conversations often revolved around developer tooling, onboarding, and the unique challenges of learning Rust. Highlights included energetic quiz sessions and insightful discussions with notable community members like Vlad Beskrovny, Lori Lorusso, and Stefan Baumgartner. RustWeek underscored the vibrant and expanding Rust community, marked by curiosity, collaboration, and enthusiasm, which continues to drive the language's evolution and adoption.

WPF Hot Reload is now available in Rider with the 2026.2 EAP 2 build, allowing developers to edit XAML in real-time while their application runs under the debugger, thus completing the Edit and Continue workflow for WPF alongside existing C# Hot Reload support. This feature addresses one of the most requested improvements in Rider's history and streamlines the development process by eliminating the need for rebuilding and navigating back through application screens, which is especially beneficial for large, complex WPF applications and dual-IDE setups. While currently in beta and not yet covering all scenarios, WPF Hot Reload supports the latest .NET and .NET Framework versions, and JetBrains encourages user feedback to prioritize resolving current limitations, such as issues with adding new controls or changing runtime resources. Developers are urged to test the feature on real projects and provide feedback to help guide future enhancements.

Kotlin 2.4.0 has been released, featuring several significant updates across different platforms and tools. Key language enhancements include stable context parameters and explicit backing fields, while the standard library now supports UUID API and sorted order checks. Kotlin/JVM introduces support for Java 26 and default annotations in metadata, and Kotlin/Native adds Swift package dependencies and CMS GC enabled by default. Kotlin/Wasm supports incremental compilation and the WebAssembly Component Model, whereas Kotlin/JS allows value class export and ES2015 features. The release is compatible with Gradle 9.5.0 and offers Java and JVM target alignment in Maven, with the Kotlin compiler improving inline function consistency. Installation is straightforward via IntelliJ IDEA, Android Studio, or by updating build scripts, and the release acknowledges contributors and issue reporters who played crucial roles in its development.

IntelliJ IDEA 2025.3.6 has been released, featuring the latest Oracle critical patch update for Java 21, along with corresponding JetBrains Runtime changes to enhance reliability and security. Users can update to this version directly from the IDE, through the Toolbox App, by using snaps on Ubuntu, or by downloading it from the website. For a detailed list of fixes included in this release, users are encouraged to review the release notes, and any issues can be reported via the issue tracker.

IntelliJ Platform has introduced asynchronous Virtual File System (VFS) content writes to improve performance, especially in scenarios involving slow or remote file systems. This change affects how plugin authors should handle file saves and reads, particularly when interacting with external processes or using direct disk access methods like Path, File, or Files. While code using IntelliJ's file APIs can see updates immediately, direct disk access may require an explicit flush of pending VFS writes to ensure the latest content is read. This asynchronous behavior helps reduce freezes during document saves but requires plugin authors to be aware of potential stale reads or flaky tests due to the difference in file system views. The update is enabled by default for files saved from the editor, but not every write operation is async unless explicitly opted in. Plugin developers should audit their code for assumptions related to saveAllDocuments() and consider flushing pending updates when disk visibility is critical.

Toolbox App 3.5 enhances remote development observability and enterprise configuration while improving user interactions by introducing features like interface zooming with familiar shortcuts, OpenTelemetry metrics for monitoring remote development connections, and clearer update progress indicators. It addresses reliability issues by fixing bugs such as the disappearance of IntelliJ-based IDEs and ensuring the consistent display of taskbar and app icons on various operating systems. For enterprise users, it streamlines communication by sending both static and dynamic headers to backend services, with automatic updates to running IDEs. The app also resolves remote development problems, such as SSH canonicalization failures and empty environment listings, and encourages user feedback to continue refining the product.

By 2026, the landscape of AI development has shifted significantly towards agentic systems, which are long-running, goal-driven software built using agentic frameworks, becoming essential in modern application architecture. These frameworks, such as LangChain, LangGraph, and AutoGen, provide the necessary infrastructure for Python developers to create autonomous systems that manage reasoning, memory, tools, and collaboration among multiple agents. AI agents, capable of autonomous reasoning and decision-making, function through a perceive, reason, act, and reflect cycle, distinguishing them from traditional AI systems that require continuous user input. Agentic frameworks support various orchestration models, including graph-based, role-based, and chain-based, each with its strengths and limitations in terms of control, flexibility, and predictability. The choice of framework depends on the specific needs of the application, whether it requires stringent control and reliability, rapid prototyping and collaboration, or adaptive and flexible workflows, making agentic frameworks a foundational component in the development of scalable, trustworthy, and auditable AI-driven applications.

Jakub Chrzanowski discusses a method to integrate OAuth2 authentication into JetBrains IDE plugins, focusing on avoiding the insecure practice of requiring users to paste personal access tokens. Instead, the proposed approach uses OAuth2 for secure and limited access, allowing users to authenticate through a familiar browser login, with the plugin receiving and storing the access token securely in PasswordSafe. The process involves generating a state, code verifier, and code challenge, which are used to ensure the security and validity of the token exchange, especially through the Proof Key for Code Exchange (PKCE) method. The article explains the flow of authentication, from user login to token storage, and emphasizes the importance of assigning responsibilities correctly within the plugin's architecture. The sample code provided demonstrates how to implement this flow using GitHub as the OAuth2 provider, ensuring that API code remains independent of the authentication mechanism.

Efim Samoylov discusses how Qodana, a code analysis tool, addresses gaps in TypeScript projects that are not covered by ESLint, such as cross-file analysis for issues like unused exports, implicit any propagation, non-null assertions, floating promises, and duplicated logic across files. While ESLint is commonly used in TypeScript projects to catch obvious issues, it operates within the scope of individual files and requires type-aware configurations for comprehensive analysis, which can be complex and less common. Qodana overcomes these limitations by offering whole-project analysis with type-aware checks that consistently flag problematic patterns, such as the silent propagation of any types, unsafe non-null assertions, unawaited promises leading to runtime errors, and duplicated logic leading to maintenance challenges. The tool integrates into the CI pipeline without blocking ongoing development by using a baseline feature that records the current state of the codebase, allowing teams to focus on newly introduced issues while keeping the existing backlog visible without hindering the workflow.

Mellum2, an AI model developed by JetBrains and now open-sourced under the Apache 2.0 license, is designed to address core challenges in AI production systems, such as latency, throughput, and cost, primarily in software engineering environments. With a Mixture-of-Experts architecture, Mellum2 utilizes 12 billion parameters but activates only 2.5 billion per token, leading to lower compute costs and faster inference times. This model is specialized in natural language and code, making it highly suitable for tasks such as routing, summarization, and intermediate reasoning in AI workflows. Mellum2's design philosophy emphasizes the importance of "focal models," which are fast, specialized components that perform high-frequency tasks efficiently, as opposed to relying solely on large, multimodal models. It offers a cost-effective and high-performance solution for routing AI workloads, building low-latency retrieval-augmented generation (RAG) pipelines, and enabling private, local AI deployments, thereby providing a significant competitive edge in production-grade AI applications.