March 2026 Summaries
74 posts from JetBrains
Filter
Month:
Year:
Post Summaries
Back to Blog
March was an eventful month for the Kotlin programming language, marked by the release of Kotlin 2.3.20, which brought improvements such as bug fixes and performance enhancements. The Kotlin Foundation Grants Program announced its winners, recognizing five projects for their contributions to the developer ecosystem. KotlinConf’26 is approaching with a packed schedule covering topics like multiplatform, AI, and backend systems, offering attendees insights into the future direction of Kotlin. Additionally, new developments include the experimental Swift Package Manager support for Kotlin Multiplatform, the introduction of the AI observability library Tracy, and the Java-to-Kotlin conversion tool released for Visual Studio Code. The Android Gradle Plugin 9.0 is set to introduce significant changes, and IntelliJ IDEA has enhanced its coroutine inspections to improve code reliability. Enthusiasts are encouraged to participate in various events and workshops, including the upcoming KotlinConf and Google Summer of Code 2026, to further engage with the evolving Kotlin community.
Mar 31, 2026
817 words in the original blog post.
Amper 0.10 – JDK Provisioning, a Maven Converter, Custom Compiler Plugins, and More | The Amper Blog
Amper 0.10.0 introduces several new features, including JDK provisioning that allows for automatic installation of JDK 21, with options for specifying different versions via the module.yaml file, and a semi-automated Maven conversion tool that facilitates transitioning existing Maven projects to Amper by mapping dependencies and settings. This release also supports third-party Kotlin compiler plugins, enhances the IDE with improved UI for running commands and profiling JVM applications, and enhances test tool windows with better test name displays. Additional improvements include support for Maven profiles in transitive dependencies, the ability to add module descriptions in Markdown, and updates to default versions for toolchains and frameworks like Kotlin and Spring Boot. The Amper platform remains experimental, encouraging user feedback through channels like the Kotlinlang Slack and YouTrack for continued development and improvement.
Mar 31, 2026
1,038 words in the original blog post.
ReSharper has introduced a new Monitoring feature that provides real-time performance insights directly within Visual Studio, allowing developers to track CPU and memory usage, GC activity, and other metrics without needing to restart their applications in profiling mode. This update, available in ReSharper 2026.1, mirrors the Monitoring experience in Rider and requires a dotUltimate license. The tool enables users to identify performance bottlenecks by selecting specific time ranges on a chart for detailed analysis using a built-in profiler, which eliminates the need for application restarts and manual reproduction of issues. Additionally, Monitoring can automatically detect various issues such as performance hotspots and database-related problems, listing them for further investigation. It serves as a comprehensive runtime dashboard that helps developers transition smoothly from identifying symptoms to pinpointing root causes, enhancing both workflow efficiency and application performance evaluation.
Mar 31, 2026
676 words in the original blog post.
Rider 2026.1 introduces significant advancements in .NET development, game development workflows, and AI integration, enhancing the overall IDE experience. Developers can now run standalone C# programs, inspect .NET disassemblies, and manage NuGet packages with ease. Game developers benefit from improved support for Unreal Engine and Unity, including enhanced performance analysis and debugging capabilities. The release also expands AI-assisted workflows, allowing for seamless integration with various AI tools and agents, such as GitHub Copilot. Additionally, Rider 2026.1 offers better Azure DevOps integration, smoother MAUI iOS development on Windows, and introduces Beta support for CMake-based C++ projects. With strengthened language support for C# and F#, the update brings notable improvements to both coding efficiency and debugging processes, providing a robust environment for developers across different domains.
Mar 30, 2026
986 words in the original blog post.
ReSharper 2026.1 introduces significant improvements to enhance performance monitoring, expand support beyond Visual Studio, and streamline coding workflows. This update includes a new Monitoring tool window exclusive to the dotUltimate subscription, offering integrated runtime performance insights, which replaces the Dynamic Program Analysis feature set to be retired in the next release. The update extends ReSharper's C# tooling to Visual Studio Code and other compatible editors, while also delivering faster solution indexing, code completion, and analysis, aiming to make Visual Studio more responsive through Out-of-Process mode enhancements. The release also modernizes the UI for completion lists and popups, improves C# support with features like extension member handling, and adds early support for upcoming language elements. Furthermore, ReSharper 2026.1 enhances C++ performance with better startup times and lower memory usage in Unreal Engine projects, alongside new inspections and coding assistance features.
Mar 30, 2026
775 words in the original blog post.
DataSpell 2026.1 introduces several enhancements to optimize data exploration and AI integration within the IDE, featuring an expanded AI agents ecosystem that now supports Codex, Cursor, and others via the Agent Client Protocol, and an ACP Registry for easy agent installation. The release also includes the ability to export Jupyter notebooks to PDF natively within the IDE, streamlining the process by eliminating the need for external tools like Python, nbconvert, or LaTeX. Enhancements to the integrated terminal provide in-terminal completion for command and parameter suggestions, improving efficiency when using tools such as Git and Docker. Additionally, new editor caret animation modes, "Snappy" and "Gliding," are introduced to enhance the typing experience by providing smoother cursor movements. Users are encouraged to report bugs or suggest new features through the issue tracker and stay informed by subscribing to the DataSpell blog.
Mar 30, 2026
395 words in the original blog post.
RustRover 2026.1 introduces several enhancements aimed at modernizing Rust development practices, including native support for cargo-nextest to improve test execution speed and a Call Hierarchy feature for more efficient code navigation. The update also improves code analysis accuracy by reducing false positives, particularly in projects using rustc crates, and offers enhanced macro expansion visibility to streamline understanding of Rust macros. Additionally, RustRover now supports a wider array of AI agents, such as GitHub Copilot and Cursor, to assist in coding tasks, and facilitates database interaction directly within the IDE. Module creation is streamlined with configurable visibility settings, and the LLDB debugger has been updated for better performance. The version also marks the gradual discontinuation of the Code With Me service, shifting its availability to a standalone plugin in favor of integrating more contemporary development workflows.
Mar 30, 2026
956 words in the original blog post.
PyCharm 2026.1 introduces significant enhancements aimed at improving Python development by rethinking debugging, scaling, and project management with innovations like a new debugging engine powered by debugpy, which aligns with the Debug Adapter Protocol for a smoother debugging experience. The release also expands remote development capabilities with first-class uv support, allowing seamless synchronization of code and dependencies on remote servers. JavaScript support has been broadened in the free tier, making professional-grade web tools accessible to all users. Additionally, PyCharm integrates AI advancements with features like the ACP Registry for AI agents and native OpenAI Codex support, enhancing workflow flexibility. The introduction of next edit suggestions (NES) predicts code changes, making coding more efficient without consuming AI credits. These updates, among others, aim to streamline the development process, offering performance improvements and a more integrated development environment.
Mar 30, 2026
988 words in the original blog post.
The blog post, co-authored by Teodor Irkhin and Thorben Janssen, explores the integration of Kotlin with Spring Data JPA, a framework traditionally used with Java, to create a seamless persistence layer in applications. It outlines that Kotlin can be effectively utilized with Spring Data JPA, benefiting from Kotlin's compact syntax, null safety, and extension functions, without altering the established Jakarta Persistence behavior. The post details the setup process using IntelliJ IDEA, including necessary plugins and dependencies, and demonstrates how to define and use Kotlin entity classes and data classes for persistence. It also covers repository design using Spring Data JPA’s repository abstraction, which remains consistent between Java and Kotlin, and highlights how to implement custom queries using either derived query methods or the @Query annotation. Furthermore, it explains the use of Kotlin's Criteria API to create dynamic queries and stresses the efficiency of using Kotlin data classes for DTO projections. Overall, the post affirms that Kotlin’s integration with Spring Data JPA enhances code readability and maintainability, leveraging Kotlin’s features while adhering to Jakarta Persistence best practices.
Mar 30, 2026
2,595 words in the original blog post.
ReSharper C++ 2026.1 introduces significant performance enhancements, particularly for large C++ codebases and Unreal Engine projects, with faster project indexing, reduced memory usage, and improved warm startup times. This release enhances coding assistance with features like auto-import for C++20 modules and expanded postfix completion while continuing support for modern C and C++ standards, including C++26/C23 and compiler-specific extensions. The update also improves Unreal Engine development by enhancing Blueprint integration, indexing Unreal Engine plugins by default, and ensuring compatibility with Unreal Engine 5.8. Additionally, new code analysis inspections help identify subtle issues earlier, and navigation tools have been refined to facilitate working with complex codebases. The editor UI sees improvements in tooltip support and scalable UI elements across different DPI settings, offering a cleaner and more consistent experience.
Mar 30, 2026
658 words in the original blog post.
March's JetBrains Academy digest offers a range of learning opportunities, including free access to JetBrains tools for students, a summer coding camp, and the chance to apply for a scholarship-supported bachelor's program in Computer Science and Artificial Intelligence at Neapolis University Pafos. The digest highlights the JetBrains Student Pack, which provides free access to professional tools used by developers at major companies, and includes inspiring stories such as Carlos Orozco's journey from classroom learning to working on NASA challenges. It also introduces courses like "Mastering Large Language Models" and "Skill Paths" that combine guided learning with hands-on projects, as well as the Algorithm and Code Training School aimed at students aged 16–19, offering tracks in competitive programming and software engineering. Additionally, the digest mentions "Python Unplugged," an event available on demand that features insights from influential figures in the Python community.
Mar 30, 2026
381 words in the original blog post.
CLion 2026.1 introduces numerous updates focused on enhancing stability and existing functionalities while incorporating innovative features for an improved user experience. Notably, the release expands AI capabilities by supporting a variety of AI agents, including GitHub Copilot and Cursor, through the Agent Client Protocol, thus creating an open ecosystem for AI tools and workflows. Enhanced project support includes easier integration for custom and VS Code projects, improved Bazel tools, and full code insight for external CMake projects. Debugging capabilities are bolstered with TCP connections to DAP debuggers, offering more flexibility and faster remote development debugging. Language support is refined with new C and C++ features, better code folding, and improved unit testing for Meson projects. Additionally, platform updates such as smoother caret movement and Git worktrees support aim to streamline development, while the decision to sunset the Code With Me feature reflects a strategic focus on maximizing value for collaborative work.
Mar 26, 2026
1,821 words in the original blog post.
PhpStorm 2026.1 introduces a variety of features designed to enhance productivity for PHP and Laravel developers, including the new PhpStorm MCP tools and expanded support for AI third-party agents. The release includes innovations such as Git worktrees support, improved project indexing, and generics support, alongside debugging enhancements for non-PHP files and refined Laravel framework support. Additionally, the update brings advancements in TypeScript and JavaScript support, database integration via AI chat, and a refreshed editor experience with smoother animations. Native Wayland support enhances performance on Linux, while the sunset of Code With Me reflects a shift towards modern development workflows.
Mar 26, 2026
1,533 words in the original blog post.
DataGrip 2026.1 introduces several significant enhancements, including a redesigned workflow for query files and consoles, allowing users to define file names and locations, and simplifying navigation by displaying all query files under the Query Files folder in the database explorer. The update also integrates AI advancements, enabling users to create files from AI Assistant code snippets with automatic data source attachment and SQL dialect setting, while supporting AI agents like Claude Agent and Codex within the IDE. Connectivity improvements feature reusable data source templates stored in JetBrains Accounts and support for PostgreSQL 18's new features. The Explain Plan UI has been enhanced with a more informative Query Plan tab and sub-tabs for cost analysis, and the code editor now includes new caret movement animations and easier code execution options. Additionally, Microsoft SQL Server now supports JSON indexes, and file deletion behavior can be customized in system settings.
Mar 26, 2026
1,088 words in the original blog post.
Agent Skills, an open standard introduced by Anthropic, enhances AI agent capabilities by providing specialized knowledge and workflows through skills, which are essentially folders containing a SKILL.md file with instructions and metadata. This concept addresses the challenges of token consumption and effectiveness degradation by progressively managing context, loading only the necessary information when required, rather than all at once. A practical application is demonstrated with Spring Data JPA, where a skill helps prevent common mistakes such as the N+1 SELECT issue and in-memory pagination by providing coding guidelines and examples. Skills can be used with various AI agents like Claude Code, Codex, Gemini CLI, and JetBrains Junie, facilitating better adherence to coding standards and improving performance by automatically integrating and applying these guidelines in software development workflows.
Mar 26, 2026
1,384 words in the original blog post.
A large-scale observational study leveraging IntelliJ IDEA telemetry data reveals that development cycles in Kotlin-oriented projects are generally shorter than in comparable Java-oriented projects, with Kotlin cycles being approximately 15–20% shorter for small to large tasks. The study, conducted on data from about 320,000 developers over 20 months, adopts a rigorous statistical framework to control for potential biases, such as user and project differences, time trends, and task sizes. While the transition to Kotlin does not result in an immediate speedup, Kotlin projects show less degradation in cycle times over time compared to Java projects, which tend to experience considerable cycle-time growth. The research acknowledges its observational nature and potential limitations, such as unobserved team characteristics, and suggests future directions like the use of propensity score matching and exploring the effects in Android Studio. Despite JetBrains' involvement as the creator of Kotlin, the study employs multiple control groups and validity checks to ensure the reliability of its findings.
Mar 26, 2026
4,373 words in the original blog post.
GoLand 2026.1 introduces a range of features aimed at enhancing the efficiency and modernity of Go programming workflows. This release includes guided syntax updates for Go 1.26, enabling developers to easily adopt new language improvements across their codebase by identifying outdated patterns and suggesting modern alternatives directly in the editor. The IDE also improves productivity with support for Git worktrees, enabling simultaneous work on multiple branches, and enhances cloud and infrastructure workflows with better management of Terraform Stacks. Additionally, GoLand 2026.1 expands AI capabilities by supporting various AI agents through the Agent Client Protocol (ACP), offering developers more flexibility in using AI during development tasks. The editor experience is refined with smoother animations and selection behavior, while Linux users benefit from native Wayland integration for better rendering and input handling. However, GoLand announces the sunsetting of Code With Me, transitioning it to a separate plugin available on JetBrains Marketplace due to declining demand.
Mar 26, 2026
983 words in the original blog post.
RubyMine 2026.1 introduces a variety of enhancements aimed at improving Ruby and Rails development, with a focus on integrating AI tools, increasing code insight capabilities, and stabilizing remote development. This release supports multiple AI agents, including Codex and GitHub Copilot, and facilitates database interaction through AI chat, while the experimental code insight engine promises faster and more reliable symbol-based language modeling. Remote development is now stable, allowing seamless connection to development environments via SSH and other methods. The update also includes advancements in Rails support, such as accurate recognition of local variables and deprecated associations, and introduces recognition for PostgreSQL virtual generated columns. RubyMine enhances user experience with improved test debugging and simplified configuration for linting and formatting, while also preparing for the future unbundling of Code With Me as a separate plugin.
Mar 26, 2026
1,238 words in the original blog post.
IntelliJ IDEA 2026.1 introduces a range of enhancements and fixes, addressing over 1,000 bugs and usability issues, with significant improvements in performance, terminal usability, and JVM language support. The update focuses on boosting application reliability by tackling UI freezes and optimizing operations through automatic error reporting. Terminal enhancements streamline workflows involving CLI-based AI agents, while Kotlin and Scala support see advancements in bean registration and code highlighting, respectively. The user interface now offers synchronized theme settings for Linux, OpenType stylistic sets, and improved accessibility for Windows users. Version control improvements include streamlined commit amendments, automated fetching of Git changes, and enhanced support for GitLab merge requests. Database functionalities see improved Explain Plan workflows, while JetBrains introduces the lightweight jetbrainsd service for handling protocol links. As IntelliJ IDEA sunsets the Code With Me feature, it becomes available as a separate plugin, and organizations gain new AI management tools via the JetBrains Console, offering insights into AI usage and adoption within teams.
Mar 25, 2026
1,232 words in the original blog post.
PyCharm 2026.1 introduces a significant expansion of its core web development tools, making professional-grade features available for free to all users, including beginners and backend developers. This update includes comprehensive support for JavaScript, TypeScript, and CSS, with enhanced capabilities such as code completion, import management, and styling features tailored for modern web development. Users can benefit from smart editor behavior, efficient navigation with pro-grade tools, and essential refactoring options to maintain high code standards. Additionally, PyCharm now supports popular frontend frameworks and integrates standard tools like Prettier, ESLint, and StyleLint, alongside features for project initialization, script management, and security checks. This broadened toolset aims to empower users to tackle real-world tasks effectively, supporting both commercial and non-commercial projects, and facilitating growth from learning stages to professional development within a single powerful IDE.
Mar 25, 2026
427 words in the original blog post.
IntelliJ IDEA 2026.1 has been released, featuring a host of new capabilities and enhancements aimed at improving the coding experience for developers. This update introduces built-in support for various AI agents like Codex and Cursor, along with first-class improvements for Java, Kotlin, and Spring. It also offers seamless support for new languages and tools from the outset, such as Java 26 and Kotlin 2.3.20, and enhances productivity with features like expanded command completion and better performance for large-scale TypeScript projects. The release includes a native Dev Container workflow, allowing developers to work with containerized projects as if they were local. Stability, performance, and usability improvements are also part of version 2026.1, and users are encouraged to provide feedback to shape future updates.
Mar 25, 2026
469 words in the original blog post.
In 2026, continuous integration (CI) and continuous delivery/deployment (CD) tools are integral to modern software development, enabling teams to release code more frequently and obtain rapid feedback. CI/CD tools such as GitHub Actions, Jenkins, and GitLab CI are widely used, with GitHub Actions leading in personal projects due to its ease of setup within the GitHub ecosystem. However, organizational use reveals a more diverse landscape, with Jenkins and GitLab CI also commonly adopted. Despite the prevalence of CI/CD tools, a significant portion of organizations still rely on manual processes, highlighting barriers to adoption such as complexity and cost. The choice of tools often depends on factors like infrastructure control, integration capabilities, scalability, and security features. Open-source tools offer flexibility and control but require significant maintenance, while commercial platforms provide comprehensive support and faster onboarding, albeit with potential vendor lock-in. The landscape is further complicated by varied organizational needs, such as compliance and governance, leading to a mixed use of tools across projects.
Mar 25, 2026
5,550 words in the original blog post.
WebStorm 2026.1 is a significant update that enhances web development workflows by improving TypeScript support, integrating AI tools, and updating framework compatibility. The release introduces a service-powered TypeScript engine for better performance in large projects, aligns with TypeScript 6, and supports new syntax and directives in popular frameworks such as React, Angular, and Vue. AI tools like Junie, Claude Agent, and Codex are integrated directly into the IDE's chat, with an ACP Registry enabling easy discovery and installation of additional AI agents. Modern CSS color support, a configurable Astro language server, and improved Svelte component handling are also notable features. The update marks the sunsetting of the Code With Me service, shifting focus to more modern developer workflows, and introduces native Wayland support for enhanced Linux performance. Overall, WebStorm 2026.1 aims to keep developers productive by ensuring seamless integration with evolving technologies and improving in-editor experiences.
Mar 25, 2026
1,240 words in the original blog post.
JetBrains Central is introduced as a transformative open system for agent-driven software development, aiming to integrate AI agents into existing software production workflows to enhance efficiency and scalability. With AI increasingly influencing software development, JetBrains Central serves as a control and execution hub, connecting tools, agents, and infrastructure to offer governance, policy enforcement, and agent optimization across development environments. It is designed to allow developers to leverage AI agents while maintaining visibility and control over outcomes, enabling complex engineering tasks and collaborative workflows without requiring costly replatforming. The system emphasizes a no-lock-in approach, allowing seamless integration of new tools and models while preserving existing systems. JetBrains Central is positioned to facilitate the shift toward AI-native development by providing a semantic context and intelligent task routing, ensuring that AI agents operate with a system-level understanding within real production environments. The Early Access Program will launch in 2026, inviting design partners to test the system's capabilities and scalability in real-world settings.
Mar 24, 2026
1,115 words in the original blog post.
In the evolving landscape of data analytics, the role of data teams is transforming with the rise of AI-driven analytics, emphasizing the need for a robust semantic layer to ensure reliable outcomes. The shift from traditional dashboard analytics to agentic analytics requires data analysts to focus on defining clear metrics, building semantic contracts, and establishing governance and versioning standards. This transition is supported by the development of a strong foundational framework, where metrics are standardized in code and managed through Git-based systems with strict guardrails. Emerging trends show a preference for small teams of specialized AI agents, each performing distinct roles such as discovery, semantic layer authoring, and auditing, with humans overseeing and approving critical decisions. The industry is also witnessing a division into three main approaches: end-to-end conversational analytics platforms, enterprise BI with AI add-ons, and headless semantic infrastructure, the latter offering greater control and scalability. The introduction of the Open Semantic Interchange (OSI) aims to create a vendor-neutral standard for semantic models, enhancing interoperability across tools. Databao, a new JetBrains product, supports this paradigm by helping data teams create a shared semantic context and develop data agents, fostering an AI-native analytics experience that business users can trust.
Mar 23, 2026
1,221 words in the original blog post.
Josh Long, the first Spring Developer Advocate since 2010, reflects on the evolution of the Spring ecosystem from traditional enterprise applications to microservices and AI-powered services, emphasizing the growth and adaptability of the community. He highlights Kotlin's natural fit for Spring due to its expressive language and the collaborative efforts between the Spring and Kotlin teams, which have resulted in seamless integrations and enhanced developer experiences. Long notes that the JVM's performance and scalability make it an excellent platform for developing modern applications, including AI integrations, which often require efficient communication with existing systems. He underscores the importance of integration in successful AI projects and suggests that extending existing JVM-based services with tools like Spring AI and Kotlin can lead to more effective outcomes. Josh will further explore these themes in his talk at KotlinConf’26, emphasizing the synergy between Kotlin and Spring Boot for a more productive development experience.
Mar 23, 2026
1,968 words in the original blog post.
OpenAI's acquisition of Astral, known for its popular Python tools such as uv, Ruff, and ty, marks a significant development for the Python ecosystem, with Astral's team joining OpenAI's Codex team pending regulatory approval. Astral's tools, which have revolutionized Python tooling with hundreds of millions of monthly downloads, include uv, a comprehensive package and environment manager; Ruff, a fast linter and formatter; and ty, an emerging type checker. JetBrains, the company behind PyCharm, has integrated these tools into their platform and maintains a commitment to supporting them, despite potential risks of stagnation following the acquisition. However, the open-source nature of Astral’s tools and both companies' commitment to continued development provide reassurance, with JetBrains optimistic that the acquisition will enhance the Python ecosystem without diminishing Astral's contributions.
Mar 23, 2026
477 words in the original blog post.
The IntelliJ Scala Plugin 2026.1 update introduces a variety of enhancements and fixes for Scala developers, including improved project import times for sbt projects, support for virtualized environments like WSL and Docker, and refined settings for code highlighting and compiler-based highlighting. The release also addresses issues related to the bspEnabled flag, ensuring consistency across BSP and regular sbt imports, and provides compatibility warnings for sbt 2.0 with older JDK versions. Significant updates include support for the new Scaladoc with Markdown syntax while maintaining compatibility with older WikiDoc syntax, advancements in Scala 3 language feature support, and fully enabled AI Assistant for next edit suggestions. The update also improves type inference, resolves issues with extension methods, and enhances Structural Search and Replace functionality, inviting users to provide feedback on these developments.
Mar 23, 2026
1,050 words in the original blog post.
ReSharper 2026.1 Release Candidate introduces significant enhancements aimed at improving .NET development efficiency and predictability with a focus on code analysis, language support, and runtime performance monitoring. The release debuts a new Monitoring tool window that consolidates runtime performance metrics, replacing the Dynamic Program Analysis feature in future releases. ReSharper now extends its support to Visual Studio Code and compatible editors, bringing its features such as code analysis and refactoring to a wider audience. The update also enhances support for modern C# features, making code writing safer and more efficient, while offering faster code analysis and indexing. Additionally, ReSharper C++ sees improvements in performance, language support, and coding assistance, particularly for Unreal Engine projects. The release also brings a refreshed editor UI for better alignment with Visual Studio’s modern design. Users are encouraged to download the release candidate and provide feedback through YouTrack.
Mar 20, 2026
743 words in the original blog post.
KotlinConf 2026 offers an extensive and diverse schedule designed to cater to Kotlin developers at various expertise levels, featuring a range of sessions from foundational talks to advanced deep dives. The conference addresses multiple facets of Kotlin development, including language evolution, data science applications, terminal interactions, AI integration, and cross-platform solutions. Highlights include discussions on evolving language defaults by JetBrains' lead language designer, practical sessions on data science with Kotlin tools, and advanced topics like Kotlin Native integration and compiler internals. Additionally, sessions explore Kotlin's role in powering large-scale systems at companies like Google and Uber, and its strategic adoption in fintech for reliability and risk management. The event also delves into AI's growing influence in software development, with insights on building scalable AI agents and improving AI-generated Kotlin code. With parallel tracks and a plethora of engaging topics, attendees are encouraged to carefully plan their schedules to maximize their experience at this global gathering of the Kotlin community.
Mar 20, 2026
1,802 words in the original blog post.
The Rider 2026.1 Release Candidate introduces several enhancements to improve the development experience within the .NET ecosystem, including better support for file-based C# programs, an ASM Viewer for .NET disassemblies, and a NuGet Package Manager Console. The update also streamlines the development of MAUI iOS apps from Windows by automating setup processes and supports mobile game development for Unreal Engine on both Android and iOS. Game development workflows benefit from faster Unreal Engine debugging and improved Blueprint functionality, while CMake support for C++ projects is introduced in beta. The release also improves Unity Profiler integration and offers mixed-mode debugging capabilities for Windows game development, allowing seamless debugging of managed and native code. Language support updates include enhancements for C#, C++, and F#, with C# developments powered by ReSharper. The Rider team invites users to try the release candidate and provide feedback.
Mar 20, 2026
912 words in the original blog post.
IntelliJ IDEA has introduced new Kotlin coroutine inspections to help developers write cleaner and more efficient code, addressing common issues in codebases that Marcin Moskała, a Kotlin expert, has often encountered. These inspections, available in IntelliJ IDEA 2025.2 and later, aim to guide developers in adopting best practices, such as using `awaitAll()` and `joinAll()` for cleaner and more efficient task handling, employing `currentCoroutineContext()` instead of `coroutineContext` to avoid context mismanagement, and avoiding `runBlocking` inside suspending functions to prevent thread blocking. The inspections also discourage using `Job` as an argument in coroutine starters due to its potential to disrupt structured concurrency, advise using `suspendCancellableCoroutine` over `suspendCoroutine` for better cancellation support, and highlight the importance of scope management to prevent memory leaks. Additionally, the IDE suggests simpler operations for flow processing, like `mapNotNull`, enhancing the core development experience by making correct usage more intuitive while mitigating common pitfalls.
Mar 19, 2026
1,570 words in the original blog post.
IntelliJ IDEA is making core features for JavaScript, TypeScript, HTML, and CSS, previously exclusive to its Ultimate subscription, available for free in version 2026.1 to enhance modern Java development involving web technologies. This update includes essential React support, comprehensive syntax highlighting, reliable code completion, and advanced import management to improve efficiency and reduce errors in web application development. The platform also offers smooth code navigation, robust refactoring tools, and quality control features to maintain code integrity. Integrated workflows within the IDE now allow for streamlined project management, security monitoring, and consistency with tools like Prettier and ESLint. While these core features are free, advanced tools for full-stack development remain part of the Ultimate subscription, which can be accessed through a 30-day trial.
Mar 19, 2026
422 words in the original blog post.
Many enterprises claim to have AI governance in place, but often the reality is that these systems lack the necessary visibility and control when AI agents operate at scale within production environments. Traditional governance frameworks, which rely on static policies and approval processes, are inadequate for dynamic, autonomous agents that make micro-decisions beyond the anticipated scope. This results in a false sense of control and increased risk, as organizations assume rules will naturally lead to desired behaviors. The absence of real-time monitoring and economic visibility further complicates governance, making it largely performative and ineffective. To achieve meaningful oversight, governance must be integrated into the AI systems themselves, with mechanisms for runtime enforcement, structured orchestration, and transparent cost attribution. This would enable different stakeholders to have actionable insights at their respective levels, facilitating confident scaling and reducing the gap between aspirational and operational governance as AI adoption accelerates.
Mar 19, 2026
1,004 words in the original blog post.
TeamCity CLI is a versatile, open-source tool designed to streamline the management of TeamCity builds and agents directly from the command line, eliminating the need to navigate through a browser interface. With over 60 commands available, it offers functionalities such as starting builds, viewing logs, managing build agents, and accessing queues, while also providing direct access to the full TeamCity REST API for tasks not covered by the CLI. The tool supports seamless integration with automation workflows and AI coding agents, allowing for efficient pipeline management and the execution of commands remotely without needing SSH keys or VPNs. TeamCity CLI is open-source under the Apache 2.0 license and actively seeks user feedback to enhance features like pipeline visualization and integration with version control systems. Installation is straightforward across operating systems, and it is designed to be a building block for automation, offering structured data output for dashboards or scripts.
Mar 19, 2026
763 words in the original blog post.
In the comparison between SonarQube and Qodana, both are evaluated as robust static code analysis tools, but they cater to different team needs and development philosophies. SonarQube is highlighted for its centralized governance, broad language coverage, and UI-managed quality profiles, making it suitable for enterprise environments that prioritize top-down quality management. On the other hand, Qodana integrates seamlessly with JetBrains IDEs and CI/CD pipelines, offering a developer-centric approach with configuration as code, which is ideal for teams practicing CI-first or GitOps development. While each platform provides core static analysis, auditing, and security capabilities, they differ significantly in setup, cost, and maintenance, with Qodana being more appealing to teams that favor Git-native workflows and prefer transparency and traceability in their code quality processes. As development practices evolve with AI-generated code and automated pipelines, teams are encouraged to align their choice of tool with their specific workflow needs and organizational priorities.
Mar 19, 2026
1,738 words in the original blog post.
CloudBees CI and JetBrains TeamCity offer distinct approaches to enterprise CI/CD solutions beyond Jenkins, addressing the operational overhead associated with Jenkins' flexibility. CloudBees CI builds upon Jenkins by adding enterprise-grade governance, centralized management, and commercial support, making it a suitable choice for organizations looking to enhance their existing Jenkins infrastructure while maintaining control and scalability. In contrast, TeamCity provides a purpose-built CI/CD platform with integrated features such as pipeline modeling, test reporting, and configuration via Kotlin DSL, which reduces reliance on plugins and simplifies long-term maintenance. CloudBees requires managing multiple Jenkins controllers, benefiting from a vast plugin ecosystem, whereas TeamCity centralizes orchestration with built-in capabilities, leading to more predictable behavior and reduced maintenance overhead. Both platforms offer enterprise-grade security and scalability, but they differ in their implementation of governance and integration ecosystems. The choice between them depends on whether an organization prefers to extend its Jenkins environment with CloudBees or adopt TeamCity's streamlined, less complex platform.
Mar 18, 2026
1,050 words in the original blog post.
Google Summer of Code (GSoC) 2026 is offering an opportunity for students and eligible contributors to engage with the Kotlin Foundation by working on open-source projects over the summer. Participants can gain valuable production experience, mentorship from seasoned engineers, and a stipend while contributing to the Kotlin ecosystem. Projects available this year include developing a new fuzzer for the Kotlin compiler, creating a proof of concept for Swift-to-Kotlin interoperability, implementing tail call support in Kotlin/Wasm, and researching the global landscape of Kotlin education. Interested applicants are encouraged to explore project ideas, connect with mentors on Kotlin Slack, and submit their applications by March 31. Those not eligible for GSoC might consider the Kotlin Ecosystem Mentorship Program for other collaborative opportunities.
Mar 18, 2026
403 words in the original blog post.
Jenkins, a widely used CI/CD tool, faces scaling challenges as organizations grow, primarily due to its single-controller architecture, which can become a bottleneck with increasing build demands. This setup competes for resources and leads to issues like slow performance and controller instability when the number of builds and complexity increases, making operational costs and plugin management difficult. Organizations typically attempt to scale by using either a large centralized controller, which risks single points of failure, or multiple controllers, leading to "instance sprawl" and maintenance challenges. In contrast, modern platforms like TeamCity offer a server-agent architecture emphasizing built-in integrations and centralized governance, which reduces dependency on plugins and operational overhead. This architectural distinction allows TeamCity to offer more predictable and stable CI/CD operations at scale, prompting organizations to consider whether they should focus on engineering their CI platform or their product.
Mar 17, 2026
1,009 words in the original blog post.
Koog for Java, an enterprise AI agent framework developed by JetBrains, integrates seamlessly with Java-based systems, allowing AI agents to be built directly within existing backends without the need for separate Python microservices. It offers a structured, fault-tolerant, and observable approach to orchestrating large language models (LLMs), making use of fluent builder-style APIs and native Java abstractions. The framework supports multiple workflow strategies, including functional, graph-based, and planning, to provide control over task execution order and tool availability, while ensuring fault tolerance through persistence features that save agent state to prevent progress loss. With integration capabilities for Spring Boot and support for major LLM providers like OpenAI and Google, Koog also enhances observability using OpenTelemetry, allowing for detailed monitoring of agent execution, token usage, and costs. Additionally, Koog offers history compression to optimize token usage and thread management for efficient resource allocation, making it a robust solution for incorporating AI agents in enterprise environments.
Mar 17, 2026
1,797 words in the original blog post.
Toolbox App 3.4 from JetBrains introduces several updates and fixes, enhancing user experience and developer capabilities. Notably, it offers plugin API callbacks for remote IDE lifecycle events, allowing plugin developers to execute custom logic before and after an IDE launch. This version addresses previous issues on macOS by ensuring the Toolbox window remains stable in full-screen mode, especially on MacBooks with a notch. It also provides support for Windows users with non-ASCII usernames, eliminating the need for workarounds. Additionally, improvements in remote development include resolving file descriptor leaks on Linux and enhancing connection stability with enabled TCP keepalive for OpenSSH. The jetbrainsd service receives updates for better reliability, such as automatic timeout exits and correct protocol link handling on Linux systems without full desktop environments. Overall, these updates aim to improve functionality and stability for users and developers alike.
Mar 17, 2026
443 words in the original blog post.
IntelliJ IDEA 2025.3.4 has been released, offering full support for Java 26 alongside several key improvements and bug fixes. Users can upgrade to this version through the IDE, the Toolbox App, snaps for Ubuntu, or by downloading from the website. Noteworthy improvements include resolving an issue where running an HTTP request could unintentionally trigger a different request in the same file, ensuring local changes refresh correctly in large Perforce projects, and fixing the Dependencies tab to open properly when using the Analyze Cyclic Dependencies feature. Users are encouraged to check the release notes for a detailed list of fixes and report any issues via the issue tracker.
Mar 17, 2026
169 words in the original blog post.
Java 26, released on March 17, 2026, introduces several performance improvements and new library additions, although it includes no new stable language features. Supported by IntelliJ IDEA, Java 26 brings ten JEPs, with highlights including JEP 516's advancements in ahead-of-time object caching to enhance startup and warmup performance, JEP 517's integration of HTTP/3 for the HTTP Client API, and JEP 522's improvements to the G1 garbage collector's throughput. Additionally, preview features such as enhanced pattern matching for primitive types and the Vector API continue to evolve, with IntelliJ IDEA providing comprehensive support for these features. The release also marks the removal of the Applet API, which has been deprecated since JDK 17. Developers can experiment with these features using IntelliJ IDEA's built-in tools, which facilitate easy setup and configuration of Java 26, including preview and incubator features.
Mar 17, 2026
2,235 words in the original blog post.
In JetBrains IDEs, UI freezes are often attributed to heavy work on the Event Dispatch Thread (EDT), but a significant cause can also be traced to long, non-cancellable read actions running in background threads, particularly within plugins. These actions, which are not inherently cancellable, can block write actions and freeze the UI, as they demand exclusive access when write actions are requested. The IntelliJ Platform employs a reader-writer lock system, allowing multiple read actions to run concurrently but requiring read actions to complete before a write action can proceed. When these read actions are lengthy, they prevent necessary write actions from occurring, thus freezing the UI. To mitigate this issue, it is advised to avoid using ReadAction.compute for long tasks in background threads, and instead, utilize cancellable read actions or split tasks into smaller, manageable chunks. The article highlights the importance of rewriting plugin code paths to prevent UI freezes, emphasizing that non-cancellable reads can significantly affect platform performance. Upcoming sessions aim to guide developers on creating freeze-safe plugin code to maintain the responsiveness of JetBrains IDEs.
Mar 17, 2026
1,214 words in the original blog post.
Kotlin 2.3.20 introduces several enhancements and updates, including compatibility with Gradle 9.3.0 and the default use of the Build tools API for Kotlin/JVM compilation. Maven users will experience a simplified setup for Kotlin projects, while the Kotlin compiler plugins see the Lombok plugin in Alpha and improved support in the kotlin.plugin.jpa plugin. The language now supports name-based destructuring declarations, and the standard library introduces a new API for creating immutable copies of Map.Entry. Kotlin/Native benefits from a new interoperability mode for C and Objective-C libraries. The release can be accessed through updated versions of IntelliJ IDEA and Android Studio, or downloaded from GitHub for the command-line compiler. Users are encouraged to report issues via YouTrack and stay informed on updates by subscribing to the Kotlin blog. Special recognition is given to EAP Champions for their contributions to this release.
Mar 16, 2026
282 words in the original blog post.
JetBrains has announced plans to discontinue "Code With Me," a feature within their IDEs that facilitated real-time collaborative coding and pair programming. The decision comes after analyzing the shift in demand for collaboration tools post-pandemic and the ongoing engineering investment needed to maintain the feature alongside the evolving IntelliJ Platform. The 2026.1 release will be the last to officially support Code With Me, and it will be available as a separate plugin until Q1 2027, after which public relay infrastructure will be deactivated. Existing users can continue utilizing the plugin on supported IDE versions and will receive security updates during a transition period. JetBrains encourages users to explore alternative collaboration tools or their enhanced remote development features, which remain a strategic focus. The company assures continued support for existing contracts and offers assistance to users during this transition.
Mar 16, 2026
976 words in the original blog post.
In the exploration of enhancing AI coding agents, a key challenge is not just producing functional code but ensuring it aligns with a project's evolving standards and conventions, especially in complex, legacy codebases. TeamCity's experiment with AI agents revealed that while agents can generate technically correct code, they often replicate outdated patterns prevalent in a repository. To address this, the team introduced CommitAtlas, an internal tool that leverages Git history to provide AI agents with contextual insights from past accepted commits and review feedback, enabling them to produce code that adheres to current project standards. This approach highlights the repository's history as a vital source of implicit knowledge, capturing the evolution of code and what the team has learned about maintaining consistency and quality. By accessing this historical context, AI agents can better align their output with the project's intent, transforming repository history into a dynamic guide that helps bridge the gap between functional and accepted code.
Mar 16, 2026
1,405 words in the original blog post.
In today's data-driven environment, organizations often face challenges with inconsistent data definitions, leading to a "trust tax" where significant resources are spent verifying data accuracy. The transition to AI-driven analytics by 2026 is expected to exacerbate these issues, as AI can quickly produce multiple versions of the truth without resolving foundational inconsistencies. Despite the promise of AI to streamline data processes, many companies mistakenly believe it will solve underlying definitional chaos without additional groundwork. The article emphasizes the importance of establishing a semantic layer—an official business dictionary that clearly defines metrics like "revenue" or "active user"—to provide clarity and prevent ambiguity in AI outputs. Databao, a new data product from JetBrains, aims to address these challenges by helping data teams create a shared semantic context, allowing for more reliable AI analytics that business users can trust.
Mar 16, 2026
1,108 words in the original blog post.
Qodana is inviting its users and past trial participants to provide feedback on its code quality platform to help improve its features, prioritize future development, and better support the workflows of DevOps teams, developers, and engineering leaders. The survey aims to gather insights into how Qodana is used to automate code reviews, enforce quality gates in CI, and monitor codebase health, ensuring smooth integration with modern CI/CD pipelines. In exchange for their participation, respondents have a chance to win one of 25 spot prizes, including a one-year All Products Pack personal subscription, a one-year personal license for a JetBrains IDE, or a $100 coupon for the JetBrains Merchandise Store. The survey, which takes approximately 8 minutes to complete, will directly influence the future evolution of Qodana, aligning it with the evolving expectations around code quality, security, automation, and visibility.
Mar 15, 2026
319 words in the original blog post.
The latest release of Datalore, version 2026.1, introduces several key features aimed at enhancing data exploration and security for users. These updates, available to both Datalore Cloud and On-Premises users, include the introduction of data explorer cells, which allow users to explore and visualize data directly from dataframes without writing additional code. This feature enables quick dataset inspection, filtering, and chart generation, all within a single interactive cell. Additionally, the release supports the Bring Your Own Key (BYOK) for AI, allowing On-Premises administrators to choose between JetBrains AI or other AI providers, aligning with company security and data governance policies. For those deploying Datalore On-Premises on Kubernetes, the update includes the use of sidecar containers for enhanced security, where a privileged sidecar container manages external resource mounting, isolating it from the notebook agent container. These improvements aim to offer more flexibility, control, and security to users working with data.
Mar 13, 2026
456 words in the original blog post.
Python Unplugged on PyTV, a virtual conference organized by the PyCharm team, successfully delivered an engaging and inclusive online experience for the global Python community on March 4, 2026. Aimed at making the conference accessible to all, the event featured a '90s music theme and included live talks, hallway tracks, and Q&A sessions from Amsterdam, the birthplace of Python. The conference hosted 15 distinguished speakers, including Travis Oliphant and Carol Willing, covering topics such as AI, data science, and web development. The event also featured panels on AI in open source and the PyLadies community, along with interactive quizzes to engage participants. Garnering over 5,500 live viewers and 8,000 additional recorded views, the success of this initiative has inspired plans for future editions, with the team welcoming community input on potential speakers and topics.
Mar 13, 2026
860 words in the original blog post.
AI4SE, a collaborative initiative between JetBrains and Delft University of Technology, aims to leverage AI advancements to transform software engineering practices, focusing on five key research tracks: testing and evaluating large language models (LLMs), adapting LLMs for coding tasks, creating interactive and aligned integrated development environments (IDEs), utilizing runtime information for development improvements, and developing intelligent teaching assistants for programming education. In 2025, significant progress was made, including the development of trigger models that optimize code completion processes, contributing to increased developer productivity. The program also supported graduate students' theses and facilitated impactful research projects, such as the creation of TreeRanker for code completion and AgentGuard for runtime verification of agentic AI systems. AI4SE's achievements in 2025, including award-winning publications and practical tools, underscore its role in reshaping software development and education, as it prepares to expand its impact in 2026 with new graduates and collaborative opportunities.
Mar 12, 2026
2,184 words in the original blog post.
AI-powered code review tools are becoming increasingly prevalent in software development, offering benefits such as faster processing of code, consistent scrutiny, enhanced security, and reduced bias in the review process. However, they also pose ethical challenges regarding accountability and transparency. When AI tools suggest changes, the responsibility for potential errors or bugs introduced by those changes becomes a complex issue, raising questions about whether the developer, the organization, or the AI vendor is accountable. The distinction between rule-based static analysis and AI-powered analysis is crucial, as the latter learns patterns from extensive code repositories and can vary based on model training and updates. Concerns about transparency and inherited biases from training data highlight the need for clear governance and accountability structures in teams using these tools. Vendors are urged to provide explainable recommendations and contextual confidence scores to support informed decision-making by developers, emphasizing that ethical AI code review requires collaboration between developers and vendors to ensure these tools enhance rather than undermine code quality.
Mar 11, 2026
2,175 words in the original blog post.
Tracy is an open-source library designed to enhance observability in AI applications built with Kotlin, facilitating debugging, performance measurement, and tracking of language model (LLM) usage. By integrating seamlessly with popular Kotlin/LLM stacks and relying on OpenTelemetry, Tracy offers flexibility in exporting trace data to various backends like Jaeger or Grafana, and integrates with LLM engineering platforms such as Langfuse. Unlike full AI frameworks that limit tracing to framework APIs, Tracy permits detailed monitoring of LLM usage through API or HTTP client instrumentation and annotating Kotlin functions, allowing developers to trace application logic and LLM call metadata efficiently. It simplifies observability by providing high-level APIs for scoped spans, LLM client instrumentation, and tool call tracing, requiring minimal code changes. As an open-source project, Tracy invites community contributions to extend its capabilities and aims to support the growing Kotlin AI ecosystem by ensuring robust observability of AI applications.
Mar 11, 2026
1,172 words in the original blog post.
Jenkins, a widely used CI/CD platform, often encounters scaling challenges as its architecture requires careful management of controller load, plugin compatibility, and governance, leading to increased operational overhead in larger installations. Jenkins uses a controller-agent model, where multiple controllers may be necessary to distribute load, but this comes with additional complexities in plugin management and maintaining consistent configurations across instances. In contrast, TeamCity offers a server-agent architecture that centralizes orchestration and configuration, allowing for horizontal agent scaling and reducing the need for extensive third-party extensions. TeamCity's built-in features, such as visual build chains and intelligent agent selection, enhance scalability and maintainability, providing a more streamlined and predictable experience for DevOps teams. This centralized approach can alleviate the operational burden associated with Jenkins, especially for organizations experiencing growth in their CI/CD requirements.
Mar 11, 2026
1,913 words in the original blog post.
Carlos Orozco's journey into big tech highlights the evolution of a computer science enthusiast into a seasoned professional, emphasizing the importance of strong fundamentals, real-world experience, and effective communication skills. Initially captivated by the systematic problem-solving nature of programming, Carlos pursued computer science, ultimately earning a PhD and becoming a professor and expert consultant in quantum software architecture for Colombia’s Ministry of Science, Technology, and Innovation. His career spans roles as a senior software engineer with global firms like EPAM and participation in the NASA International Space Apps Challenge, where he honed his ability to collaborate across disciplines. Carlos underscores the significance of balancing formal education, self-directed learning, and the responsible use of AI tools in mastering computer science, advocating for a deep understanding of concepts over simply following trends. He credits professional tools like the JetBrains Student Pack for helping him transition from academic to industry environments by supporting code quality and productivity. Carlos advises students to treat learning as a marathon, focusing on problem-solving and communication skills that ultimately distinguish them in the tech industry.
Mar 11, 2026
1,626 words in the original blog post.
Neapolis University Pafos is hosting an Open Day for its Computer Science and Artificial Intelligence bachelor's program on March 29, 2026, offering prospective students and parents the chance to explore the program and campus. Supported by the JetBrains Foundation, the program provides up to 40 full scholarships covering tuition, accommodation, medical insurance, visa fees, and a monthly allowance. The event includes presentations by faculty, interactive activities, a campus tour, and a workshop titled “Visual Exploration of Mathematical Ideas Using Python.” Additionally, prospective students can participate in a math test practice session that may enhance their admission prospects.
Mar 10, 2026
231 words in the original blog post.
JetBrains has introduced experimental AI features for its IDEs, focusing on proactive tools like "recap" and "insights" that enhance development workflows. The recap feature provides a concise summary of recent activities in a codebase, aiding developers in quickly resuming work after interruptions, while insights offer selective explanations for complex code segments, specifically for Python and JVM languages. These features are available as a separate plugin to allow users to opt-in and provide feedback, ensuring that only interested developers participate and contribute to their refinement. This approach allows JetBrains to iterate based on user feedback before potentially integrating the features into the main AI Assistant plugin. The company monitors AI quota usage closely to ensure it remains manageable, and users can disable features if needed. Future developments include refining the recap feature and exploring integration with VCS tools, with user feedback being pivotal in shaping these enhancements.
Mar 10, 2026
805 words in the original blog post.
CLion 2026.1's Early Access Program (EAP) introduces a variety of enhancements to debugging, build tools, and project formats, aiming to improve user experience and efficiency. Key updates include the ability to communicate with Debug Adapter Protocol (DAP) debuggers over TCP, offering more flexibility in debugger choices, and allowing users to view numeric values in different formats, such as decimal, hexadecimal, and binary. Debugging in remote development mode has been made more responsive and stable, with significant performance improvements for the LLDB-based custom debugger when using Natvis expressions. The bundled LLDB version has been updated, and new support for custom project models simplifies code insight and migration from VS Code. Additionally, CLion now provides full code insight for external projects and offers enhanced CMake support with code completion for command-line options and more descriptive preset names. Language support enhancements include unit testing support for Meson projects and improved code folding features in the CLion Nova engine. Users are encouraged to explore these new features during the EAP to help refine the software before its stable release.
Mar 09, 2026
1,057 words in the original blog post.
JetBrains has launched Air, a new development tool designed to integrate AI agents into the software development process, marking a shift from traditional IDEs to an agentic development environment. Built on 26 years of experience in creating developer tools, Air allows developers to delegate coding tasks to multiple AI agents and run them concurrently, providing a more cohesive and context-aware experience than the fragmented current state of agent-based development. Air is available to developers with JetBrains AI subscriptions and supports agents like Codex, Claude Agent, Gemini CLI, and Junie, while also offering the flexibility to switch between agents without disrupting workflows. It incorporates essential tools such as a terminal and Git client, enabling developers to manage agent outputs effectively within their entire codebase. The tool prioritizes agent orchestration without replacing existing workflows and supports local and sandboxed agent runs to maintain organization across projects. While the current release focuses on individual productivity, JetBrains envisions a future of enhanced human-agent collaboration starting at the task definition stage, with plans for team collaboration features and enterprise offerings in the pipeline.
Mar 09, 2026
807 words in the original blog post.
Junie CLI, a new iteration of JetBrains' Junie coding agent, is now in beta, offering a standalone AI solution that integrates seamlessly across various development environments such as terminals, IDEs, CI/CD pipelines, GitHub, and GitLab. It is LLM-agnostic, meaning it supports multiple high-performing models from providers like OpenAI, Anthropic, Google, and Grok, and is designed to be adaptable to developer workflows with features like customizable guidelines, agent skills, and commands. Junie CLI is powered by JetBrains intelligence, combining large language model capabilities with deep project context and workflow awareness, and offers real-time prompting and next-task prediction to enhance performance and accuracy. The pricing model is flexible, allowing developers to use their own model keys (BYOK) without additional platform charges, supporting integration with existing setups to ensure governance, security, and code quality. Junie aims to bridge the gap between different platforms, expanding beyond JetBrains IDEs to enable professional-level development across diverse environments.
Mar 09, 2026
618 words in the original blog post.
UI freezes in JetBrains IDE plugins present significant challenges for developers, often stemming from complex concurrent programming issues rather than just heavy work on the event dispatch thread. In an upcoming livestream on March 19, Yuriy Artamonov, Product Manager for the IntelliJ Platform, and Patrick Scheibe, IntelliJ Platform Developer Advocate, will address these issues by exploring common causes and offering practical strategies to prevent them. The session will cover problems like long-running non-cancellable read actions, network calls during read locks, and the misuse of external processes, while also providing insights into why APIs such as ReadAction.compute can block write actions, causing UI freezes even when not running on the event dispatch thread. Attendees will learn how to write freeze-safe, cancellable plugin code to maintain the responsiveness of JetBrains IDEs, and a live Q&A will offer further opportunities to discuss real-world scenarios with experts. This session is valuable for both new and experienced plugin developers looking to mitigate UI freeze issues and enhance their coding practices.
Mar 09, 2026
375 words in the original blog post.
Databao's context engine, a CLI tool designed to extract schema and metadata from data sources, assists analytics engineers like Claire Amaouche Guja at Carnival Maritime in simplifying and accelerating ad-hoc analytics processes within complex data environments. Guja's need for an efficient data discovery solution led him to Databao, as it allows for a more conversational interaction with data across multiple databases, domains, and schemas on cruise ships. Prior attempts to create a data chatbot faced challenges due to the lack of cohesive integration and the necessity of explaining context to AI agents. Databao addresses these challenges by providing a governed semantic context, facilitating accurate, context-aware responses from large language models (LLMs). This innovation reduces the time spent on data management, allowing analytics engineers to focus more on analysis rather than data preparation. The Databao platform, which integrates with any LLM, promotes self-serve analytics and is designed to make data more accessible to business users, encouraging teams to engage in proof of concept discussions and share feedback.
Mar 06, 2026
667 words in the original blog post.
The March 2026 edition of Java Annotated Monthly, curated by Irina Mariasova, offers a rich collection of articles, thought pieces, and videos that delve into the evolving world of Java and tech innovation. Highlighting the contributions of Holly Cummins, a Senior Technical Staff Member at IBM and Java Champion, the edition explores her diverse expertise in Java development and sustainability. The release of a documentary titled "IntelliJ IDEA — The IDE That Changed Java Forever" is also featured, showcasing the transformative journey of JetBrains' development tool. The publication discusses new advancements in Java, such as Project Leyden's performance enhancements and Project Babylon's GPU integration for machine learning, alongside emerging Java UI frameworks like TamboUI. Additionally, it covers fresh insights into Kotlin, AI integration in development, and upcoming conferences, offering readers a comprehensive overview of the latest trends and innovations in the programming landscape.
Mar 06, 2026
1,743 words in the original blog post.
Jenkins, a highly extensible CI/CD tool with over 1,800 plugins, often faces challenges related to plugin management that can lead to instability, security vulnerabilities, and operational overhead. Each Jenkins plugin operates in its own classloader, theoretically isolating it from others, but in practice, this isolation is incomplete, leading to version conflicts and runtime errors. Frequent issues include version conflicts where updates to one plugin can break others, security risks from unmaintained plugins, and the absence of a native audit trail, complicating compliance. To address these issues, a strategic governance process is recommended, including a default-deny approach to plugins, version pinning, dependency graph evaluations, and regular audits. While Jenkins remains a popular choice for many teams due to its capabilities and community support, successful management of its plugin ecosystem requires treating plugin governance as a critical operational discipline. Integrated CI/CD platforms offer an alternative by bundling core functionalities and reducing dependency management, but may lack the flexibility and range of integrations that Jenkins provides.
Mar 06, 2026
2,397 words in the original blog post.
ReSharper, a trusted productivity tool for C# developers in Visual Studio, has officially launched its extension for Visual Studio Code and compatible editors after a year in Public Preview. This release aims to enhance C# code quality for developers who use lightweight, flexible editor workflows, including AI-first coding environments like Cursor and Google Antigravity. ReSharper offers professional-grade code analysis, advanced inspections, refactoring, formatting for C#, Razor, Blazor, and XAML, and tools to refine AI-generated code to meet professional standards. It is available for free for non-commercial use and can be installed via the Visual Studio Code Marketplace or Open VSX Registry. The extension also supports real-time inspections, smart coding assistance, solution management, reliable unit testing, and fast navigation, even to decompiled sources. Future updates will focus on debugging support and expanding refactoring options based on user feedback.
Mar 05, 2026
783 words in the original blog post.
CI/CD plugin architectures, particularly plugin-centric models like Jenkins, present significant security risks due to their extensive reliance on independently developed plugins, which can have inconsistent security standards, delayed patching, and broad permissions. These vulnerabilities can lead to real-world security breaches, such as the 2022 BORN Group supply chain compromise. The decentralized nature of plugin development and maintenance often results in unpatched vulnerabilities and opaque dependencies, which contribute to these risks. Integrated CI/CD platforms offer a different risk profile by incorporating core functionalities natively and reducing reliance on third-party plugins, which allows for single-vendor accountability, more predictable patching cycles, and enhanced native security capabilities. Despite the inherent risks of plugin-centric architectures, Jenkins can be operated securely with disciplined operational practices, such as minimal plugin use, regular audits, and prompt patching. Switching to integrated platforms should be considered when the operational overhead of managing plugins undermines efficiency or when compliance issues arise. However, the most critical factor in maintaining security is often the team's processes and discipline rather than the choice of platform.
Mar 05, 2026
1,716 words in the original blog post.
A 2025 survey of IntelliJ Platform plugin developers reveals significant differences in the needs and behaviors of new versus experienced developers. Experienced developers, who often have extensive software development backgrounds, frequently reference the IntelliJ Platform source code and engage more actively in community resources, such as the JetBrains Platform Discourse forum, to address their needs for detailed technical understanding and precise API documentation. Conversely, new developers, who often struggle with the platform's complexity and terminology, rely more on beginner-friendly resources like Stack Overflow and YouTube to navigate challenges such as codebase navigation and API version compatibility. The survey highlights a community with diverse experience levels and needs, emphasizing the importance of tailored documentation and support to accommodate both new and seasoned developers. As a result, the IntelliJ Platform team is focused on balancing these needs by prioritizing improvements in documentation and community support, thereby enhancing the overall plugin development experience.
Mar 04, 2026
2,586 words in the original blog post.
Cursor, an AI agent known for its AI-native, agentic workflows, has joined the Agent Client Protocol (ACP) Registry and is now available in JetBrains IDEs, offering deep code intelligence features like refactoring and debugging. This integration allows users to access Cursor's agentic capabilities directly within the workflows and features they are accustomed to in JetBrains IDEs, aligning with the open ecosystem strategy that permits the use of various agents from major providers such as OpenAI and Anthropic. Users can install Cursor without needing a JetBrains AI subscription, fostering a flexible development environment without locking them into a single solution. This expansion aims to enhance software development with AI in familiar environments, providing powerful agent-driven capabilities as part of a continuously growing ACP Registry.
Mar 04, 2026
397 words in the original blog post.
dotInsights by JetBrains is a newsletter dedicated to providing recent updates and insights in the .NET and software development community, featuring a variety of topics and expert contributions. It highlights advancements such as the improvement of async and await in .NET, the introduction of tools like the Duende IdentityServer4 Migration Analysis Tool, and discussions on topics including simplifying grid layout in .NET MAUI, and the lease pattern in .NET. The newsletter also shares engaging stories and advice from experienced developers, as well as updates from JetBrains, such as the release of Rider 2025.3 with day-one support for .NET 10 and C# 14, and the results of the Developer Ecosystem Survey: The State of .NET 2025. It invites readers to explore various learning resources, community insights, and encourages interaction through comments and questions.
Mar 04, 2026
519 words in the original blog post.
In 2026, YouTrack is committed to enhancing its project management platform by prioritizing flexibility, scalability, and user feedback. They plan to support both cloud and server hosting options, countering trends set by competitors like Atlassian. Notably, YouTrack is expanding its Cloud offerings with a new data center in Frankfurt, Germany, to meet European data residency requirements. The roadmap includes improving migration processes from other tools like Jira and Confluence, introducing collaborative features in the Knowledge Base, and adding new functionalities such as Whiteboards, enhanced Gantt charts, and Agile Boards. For B2B support teams, YouTrack is expanding Helpdesk capabilities to offer customized client experiences. The integration of AI assistance into workflows aims to streamline tasks, and new opportunities are being created for app developers. The company remains responsive to user feedback, ensuring their developments align with customer needs.
Mar 02, 2026
1,404 words in the original blog post.
Migrating from Jenkins to TeamCity can enhance DevOps efficiency by reducing plugin dependency and streamlining configuration management. This step-by-step guide focuses on transitioning a single Jenkins project to TeamCity, allowing users to evaluate its features such as its user-friendly interface, native GitHub integration, and superior secrets management without disrupting existing workflows. The process involves thorough preparation, including inventorying Jenkins job dependencies and metrics, followed by implementing a TeamCity setup either on the cloud or on-premises. TeamCity supports configuration as code through Kotlin DSL, offering version control benefits and enabling a smooth transition from Jenkins's Groovy pipelines. The guide emphasizes running projects in parallel on both platforms to ensure reliability and facilitate troubleshooting before fully retiring Jenkins. This transition not only aims at a technical upgrade but also promises a more developer-friendly CI/CD environment, paving the way for broader adoption across multiple projects.
Mar 02, 2026
1,625 words in the original blog post.
Go's approach to error handling, treating errors as values rather than exceptions, demands explicit handling, which can inadvertently lead to security vulnerabilities if not managed correctly. Secure error handling in Go is crucial due to the language's common use in highly sensitive and distributed environments such as APIs and microservices, where security breaches could have significant consequences. The text emphasizes best practices for creating, wrapping, propagating, and logging errors securely, advising developers to sanitize and contain errors to prevent the disclosure of sensitive information. It highlights the importance of distinguishing between internal error details and public messages, using custom error types to enforce this separation, and ensuring that logging practices do not accidentally expose sensitive data. Furthermore, it stresses the need for error translation at trust boundaries to prevent internal architecture details from being exposed to users or external systems. The article also provides practical examples and a checklist to guide developers in implementing secure error handling in Go applications, alongside tools available in GoLand to detect potential security issues.
Mar 02, 2026
3,352 words in the original blog post.
The blog post by Jan Papesch offers an in-depth look at working with STM32 Arm TrustZone-based projects using CLion, focusing on setting up and managing such projects effectively. The TrustZone technology splits firmware into secure and non-secure zones to protect critical tasks from potential vulnerabilities in exposed interfaces like Wi-Fi or Bluetooth. The post guides users on configuring their environment, using tools like STM32CubeProgrammer and STM32CubeCLT, and setting up a project structure in CLion that includes two independent subprojects within a superproject. It also addresses debugging challenges and provides tips for managing CMake run configurations and debugging setups, including using a Generic debug server for complex cases. Additionally, it covers disabling TrustZone mode if needed and encourages user feedback to enhance STM32 project support.
Mar 02, 2026
1,537 words in the original blog post.