May 2026 Summaries
76 posts from JetBrains
Filter
Month:
Year:
Post Summaries
Back to Blog
TeamCity 2026.1.1, the first bug-fix release for TeamCity On-Premises 2026.1 servers, resolves over 20 issues, including problems with build agent IP addresses, a damaged Rake plugin, and failing uploads to S3 buckets. This update enhances performance, compatibility, stability, and security, and it allows for easy upgrades or downgrades within the 2026.1.x series without requiring backup or restoration. Users can update using the automatic update feature, downloading from the JetBrains website, or pulling the updated Docker image. Feedback and support are encouraged through the TeamCity Forum or Issue Tracker.
May 29, 2026
216 words in the original blog post.
Hibernate 7.4 introduces significant enhancements that streamline data handling and auditing processes in JPA/Hibernate-based applications. The update addresses the challenge of efficiently loading paginated data alongside associated child collections by implementing nested queries, thereby allowing pagination to occur at the database level rather than in memory, which enhances performance and reduces resource consumption. Additionally, it incorporates built-in support for temporal history and audit tables, negating the previous need for external libraries like Envers for tracking changes to entity data. History tables enable querying the state of an entity at specific points in time by storing previous versions of the data with effective and superseded timestamps, while audit tables record the sequence and type of changes made to entities. These improvements reduce the need for custom infrastructure, making Hibernate 7.4 a more robust and efficient tool for managing complex data queries and historical data tracking directly within the framework.
May 29, 2026
1,113 words in the original blog post.
JetBrains Academy's May Digest highlights several opportunities and resources for developers and educators, including up to 40 full scholarships offered by the JetBrains Foundation for the CSAI BSc program at Neapolis University Pafos, which cover tuition, accommodation, and expenses, along with a monthly stipend. The digest introduces a new self-paced course on using generative AI tools for complex code tasks and promotes the JetBrains Course Creators Program, which facilitates the integration of external programming courses into JetBrains IDEs, offering product access and technical support. Additionally, it features an essay by Clara Maine on the educational value of productive struggle and a webinar recap discussing the evolving roles in software development and AI adoption challenges.
May 29, 2026
365 words in the original blog post.
In a recent RustRover livestream, Rust engineers Lukas Wirth and Vlad Beskrovny explored the intricate workings of Rust IDEs and the challenges they face in understanding Rust code. The discussion delved into the necessity for IDEs to reimplement parts of the Rust compiler to offer features like code completion and semantic highlighting, emphasizing the difference between compilers optimizing for throughput and IDEs for latency. The evolution from RLS to rust-analyzer and RustRover was discussed, highlighting the shift towards architectures that prioritize responsiveness. The complexities of Rust's name resolution and type inference, particularly due to the language's cyclic module graph and procedural macros, were also examined. The livestream revealed how RustRover and rust-analyzer handle large projects differently, with RustRover using PSI-based indexing and rust-analyzer employing a query-driven approach. The session concluded with insights into integrating semantic analysis with debugging and the inherent complexities in Rust tooling development, underscoring both the love and challenges associated with working in the Rust ecosystem.
May 29, 2026
1,551 words in the original blog post.
AlphaEvolve, a Google DeepMind algorithm-discovery system, was utilized by JetBrains to enhance the indexing speed of IntelliJ-based IDEs, a critical feature impacting navigation, search, and other code insights. By leveraging Gemini to generate and refine algorithm improvements, AlphaEvolve aimed to identify optimization candidates within the already optimized B-tree structure of the IDEs' indexing infrastructure. The experiment focused on validating these candidates through synthetic benchmarks and full IDE integration tests, resulting in a 15-20% improvement in synthetic performance scores across sessions with more than 50 iterations. However, only one out of five generated candidates demonstrated a statistically significant improvement in real-world IDE scenarios, reducing the indexing time from a baseline of 17.4 ± 0.5 seconds to 16.6 ± 0.2 seconds. This approach highlighted the importance of integrating autonomous search with practical validation to ensure user-visible performance enhancements, underscoring AlphaEvolve's role in generating and ranking low-level optimization ideas in a space where manual exploration is challenging. The next steps involve product validation to assess improvements in the Mega Index metric, which tracks indexing performance and user satisfaction.
May 29, 2026
1,105 words in the original blog post.
dotMemory Unit, a unit testing framework designed to detect memory issues in .NET code, is being deprecated due to technical, security, and product considerations, including its lack of support for the latest .NET versions and its use of a legacy format incompatible with recent JetBrains profiling tools. The framework has outdated dependencies with known security vulnerabilities, and updating them would require substantial redesign efforts that are not feasible. Users are advised to discontinue its use, particularly in security-sensitive environments, as there will be no further maintenance, updates, or security patches. While dotMemory Unit has been a valuable tool for in-test memory profiling, JetBrains currently does not offer a direct replacement, and documentation will remain available for a limited time to address potential risks associated with its continued use.
May 28, 2026
370 words in the original blog post.
JetBrains has announced the decision to discontinue DataSpell as a standalone product, consolidating its data science and analytics functionalities into PyCharm to create a more unified ecosystem for users. This strategic move aims to streamline user experience and enhance the value offered through PyCharm by integrating features such as Jupyter notebooks and Python data analysis workflows. Starting September 1, 2026, existing DataSpell users will transition to PyCharm at no additional cost, with eligible users receiving JetBrains AI Credits matching their remaining subscription period. The transition will be phased, with DataSpell being deprecated on May 28, 2026, and automatic conversion of licenses to PyCharm Pro occurring in September. JetBrains assures continued support for data workflows within its ecosystem, while thanking the DataSpell community for their contributions and offering assistance to ease the transition process.
May 28, 2026
890 words in the original blog post.
Koog 1.0 is JetBrains' open-source framework designed to build AI agents using Kotlin and Java, offering tools, workflows, persistence, memory, observability, and integration capabilities with JVM and Kotlin Multiplatform projects. Announced at KotlinConf 2026, this release emphasizes stability, guaranteeing no breaking changes for stable modules for at least a year, and introduces significant enhancements such as local Android AI support, a redesigned Java interoperability layer, decoupled HTTP transport, and OpenTelemetry support across various environments. It also improves persistence and memory for long-running agents and includes Anthropic prompt caching to reduce latency and token costs. Koog 1.0 includes numerous fixes and API cleanups, positioning it as a robust foundation for enterprise-ready AI agent development, while encouraging users to incorporate the stable core modules into their projects and add Beta modules for evolving functionalities.
May 27, 2026
403 words in the original blog post.
Build a Live Object Detection App for the Reachy Mini With TensorFlow and PyCharm | The PyCharm Blog
In a guest post by Iulia Feroli, founder of the Back To Engineering YouTube community, the process of building a live object detection app using TensorFlow and PyCharm is detailed, specifically for deployment on the Reachy Mini, an open-source robot by Pollen Robotics, Hugging Face, and Seeed Studio. The tutorial outlines how to create an object detection pipeline with SSD MobileNet V2 from TensorFlow Hub, utilizing OpenCV for live webcam inference, and integrating this with the Reachy Mini for real-time object tracking, including head movement and antenna reactions. The project is structured in two stages: first, testing the model on a laptop to ensure functionality without hardware, and second, deploying it on the robot, where the head tracks detected objects and a web dashboard displays live annotated detections. The Reachy Mini, which resembles a physical representation of an AI agent with conversational and camera-based capabilities, highlights its potential for open-source development, allowing users to print their own parts and contribute to an app store. The post serves as a starting point for leveraging TensorFlow object detection in robotics, with all code available in the Reachy-mini-object-detection GitHub repository for further customization and exploration.
May 27, 2026
2,229 words in the original blog post.
Cloud9 JetStream is a new custom theme for JetBrains IDEs resulting from the collaboration between Cloud9 and JetBrains, designed to incorporate Cloud9's visual identity into the development environment with a dark interface, Cloud9 blue accents, and clear syntax highlighting. This theme aims to provide a familiar yet functional workspace for Cloud9 fans and developers seeking a clean, branded editor setup without altering their workflow. It is part of a broader partnership between Cloud9 and JetBrains, which has also produced various tools and experiences linking software development and esports, such as aim trainers, player picker tools, and data visualization tools. The theme is available through the JetBrains Marketplace and seeks to offer a comfortable and distinct visual identity for daily coding sessions.
May 27, 2026
414 words in the original blog post.
AI agents have reached a new level of capability by being able to autonomously set up and refine build configurations and pipelines in TeamCity, a continuous integration and delivery (CI/CD) platform. This advancement leverages structured documentation and tools like the TeamCity CLI, enabling agents to not only propose solutions but also implement them, observe outcomes, and make necessary adjustments until the desired result is achieved. The experiments conducted demonstrated that these agents could configure complex build setups and adapt to issues dynamically, reducing the traditional manual iterative process needed to achieve a working configuration. This development highlights the potential of AI agents to streamline CI/CD tasks by autonomously managing the feedback loop that typically requires human intervention, though success is contingent upon having clearly defined goals, robust documentation, and a controlled environment.
May 26, 2026
730 words in the original blog post.
Engineering teams often defer necessary codebase refactoring due to the high risk of introducing bugs and the immediate, tangible disruptions it can cause, despite its long-term benefits. However, four distinct teams found success by leveraging JetBrains' integrated development environments (IDEs), which allowed them to visualize the impact of refactoring across their entire codebase and reverse changes if needed. Wiz managed a massive monorepo with GoLand, which streamlined refactoring and kept their system adaptable. IT Manufactory used IntelliJ IDEA and WebStorm to reduce manual verification efforts during cross-stack changes in their Java and React components. NutriAdmin efficiently migrated from AngularJS to modern frameworks alongside ongoing development with WebStorm's static analysis tools. SEOBUK PRESENT utilized IntelliJ IDEA and Rider to manage refactoring in their hardware-software integrated platform, fostering a culture of small, frequent changes. These teams demonstrate that with the right tools, the long-term benefits of refactoring can be achieved without significant short-term disruption, reshaping the conventional risk-benefit analysis of codebase maintenance.
May 26, 2026
1,448 words in the original blog post.
The Early Access Program (EAP) for IntelliJ IDEA 2026.2 has commenced, offering developers the opportunity to explore new features and provide feedback before the official release. This iteration aims to strike a balance between AI-assisted and traditional development workflows, introducing enhancements such as a skill repository for AI agents, AI-powered method generation, and improved debugging capabilities like logpoints. The IDE's terminal now better supports CLI interactions, and dependency completion in build scripts has been refined to improve relevance and efficiency. Additionally, users can execute Flyway and Liquibase migrations directly from the IDE, while new debugging tools like the Hibernate Debugger offer insights into SQL queries. Enhanced support for technologies such as Java 27, Kotlin 2.4.x, and Gradle 10 is also underway, alongside ongoing efforts to improve product performance and resource efficiency. Participants are encouraged to share feedback through various platforms to help shape the final product.
May 26, 2026
757 words in the original blog post.
JetBrains Rider 2026.2 EAP 3 introduces several enhancements aimed at improving developer workflow and efficiency, including a new AI agent skill for generating unit tests with reduced token usage, leveraging dotCover coverage data to create more relevant tests. The release also features a code change preview function that allows developers to evaluate quick-fixes and context actions before applying them, offering a safer and more confident coding experience. For game developers, Rider now includes a dedicated Game Development section in the New Project dialog, with Godot as the first pilot, streamlining the creation of game and editor extensions. Additionally, the NuGet tool window has been redesigned to separate package browsing from dependency management, enhancing workflow clarity and efficiency, while optimized garbage collection settings in Rider's backend aim to reduce memory usage. These updates are complemented by a full list of improvements and fixes available in the release notes.
May 22, 2026
699 words in the original blog post.
JetBrains offers a unique workplace culture centered around autonomy, precision, and a deep connection to the tools it creates, making it a suitable environment for those who thrive on independence, accountability, and continuous improvement. The company operates on the principle of “by developers, for developers,” ensuring that every team member, regardless of their role, engages with the same level of curiosity and dedication to quality. This ethos extends beyond software development to all aspects of the company, fostering a culture where decisions are made by those deeply familiar with their work. JetBrains is privately owned, allowing it to prioritize genuine value over short-term profit, and it encourages employees to experiment and take ownership of their projects. The company values direct feedback and a relentless pursuit of excellence, which may initially seem intense but ultimately aims to enhance collective and individual performance. With a career path akin to a self-designed map rather than a traditional corporate ladder, JetBrains attracts individuals who are proactive, value independence, and are driven by the opportunity to solve challenging problems and make a significant impact.
May 22, 2026
1,278 words in the original blog post.
The introduction of the "finding-tests" skill in JetBrains Rider 2026.2 EAP aims to streamline the process of AI-assisted test generation by utilizing .NET coverage data from the dotCover tool, reducing token costs by 50% and decreasing unnecessary exploration of projects by AI agents. This new skill assists AI agents by providing them with precise test file paths, allowing them to follow existing testing conventions without the need for extensive searches through the codebase. By integrating agent skills, which are specialized workflows and knowledge extensions for AI, Rider enables more efficient test placement and style conformity, ultimately saving time and resources. While the feature is designed to enhance development workflows and reduce costs, it also requires coverage analysis that can be time-consuming for large projects. Users have the flexibility to enable or disable the skill based on project needs, and feedback from this Early Access Program will determine future enhancements, including potential automatic unit test generation to meet specific code coverage targets.
May 22, 2026
1,873 words in the original blog post.
JetBrains is enhancing the accessibility of its Integrated Development Environments (IDEs) by improving compatibility with assistive technologies like screen readers and magnifiers and refining keyboard navigation and audio feedback. On Global Accessibility Awareness Day, JetBrains announced updates that include better support for Windows Magnifier's cursor tracking and the introduction of Orca and GNOME Magnifier support on Linux, aiming to ensure accessibility across different operating systems. Additionally, improvements have been made to the IDE's keyboard navigation system, allowing users to access the main menu with Alt and navigate between parts of the interface more efficiently, while also developing richer non-visual feedback with audio cues for contextual signals and IDE state changes. These enhancements build on previous initiatives such as VoiceOver and NVDA support, a high-contrast UI theme, and color schemes for vision deficiencies, with JetBrains inviting feedback from users to further improve accessibility in future updates.
May 21, 2026
816 words in the original blog post.
Announced at KotlinConf 2026, the Alpha release of the official Kotlin extension for Visual Studio Code is now available, offering Kotlin developers an alternative to IntelliJ IDEA and Android Studio for their coding environment. The Kotlin by JetBrains extension integrates with the Kotlin Language Server, providing essential features such as code completion, diagnostics, navigation, quick fixes, and formatting, all backed by IntelliJ IDEA's code-insight infrastructure. This release is part of JetBrains' broader effort to enhance Kotlin tooling across different platforms, following the earlier introduction of a Java to Kotlin Converter extension. As an Alpha release, user feedback is crucial to refine the extension, and developers are encouraged to share their experiences and report issues on GitHub.
May 21, 2026
410 words in the original blog post.
KotlinConf’26 celebrated Kotlin's 15th anniversary by showcasing its comprehensive evolution from a programming language into a multifaceted ecosystem supporting backend, mobile, web, AI, and multiplatform development. The keynote featured advances in language design, tooling, and AI-driven workflows, emphasizing the importance of ergonomics and safety. Notable announcements included the preview of Kotlin 2.4.0, which introduces features like context parameters and multi-field value classes, and the launch of Kotlin Toolchain, a unified platform for development tasks. The event also highlighted the growing adoption of Kotlin Multiplatform, with companies like PayPal, Booking.com, and Sony leveraging its capabilities for scalable applications. The integration of AI tools, such as JetBrains’ coding agent Junie and the newly released Koog 1.0 framework, underscores Kotlin's commitment to enhancing developer productivity and building reliable AI systems. Additionally, collaborations with industry giants like Google on the K2 compiler and the Kotlin Symbol Processing tool demonstrate Kotlin's deep integration within the Android ecosystem. The conference underscored Kotlin's trajectory toward becoming a comprehensive solution for modern software development, promoting clarity, safety, and enhanced productivity across various domains.
May 21, 2026
1,897 words in the original blog post.
Kotlin has introduced a security support policy for its standard library on the JVM, addressing the needs of organizations that require formal documentation for dependency reviews and compliance. This policy stipulates that each release line, such as 2.4.x, will receive security fixes for 18 months from the release date of its .0 version, with patches backported to all active lines within this support window. This structured approach ensures that security patches are released simultaneously across all supported lines, allowing teams to maintain their qualified production versions without needing to upgrade to newer release lines. While the Kotlin release process remains unchanged, with new releases being the recommended baseline, the security support window provides a crucial framework for environments requiring stability and compliance documentation, as security issues are assigned CVE identifiers and published via the JetBrains Security advisory process. This new policy solidifies Kotlin's commitment to providing predictable and stable compatibility, especially for large codebases in sensitive industries like banking and payment infrastructure.
May 21, 2026
1,668 words in the original blog post.
TeamCity 2025.11.5, the likely final update for the TeamCity 2025.11 On-Premises servers, introduces four critical security fixes and addresses a small number of other issues, making it an essential update for users. By keeping up with these minor releases, users can benefit from performance improvements, better integration compatibility, more stable builds, and enhanced security. The update maintains compatibility with other 2025.11.x releases, allowing for seamless upgrades or downgrades without needing backup and restoration. Users can upgrade via the automatic update feature, download from the JetBrains website, or pull the updated Docker image. JetBrains encourages users to report issues and seek help through the TeamCity Forum or Issue Tracker.
May 21, 2026
205 words in the original blog post.
CLion 2026.1.2 now includes a built-in SARIF Viewer, which facilitates the review of static analysis reports within the integrated development environment. This feature is particularly beneficial for embedded and automotive teams that utilize external static analysis tools for compliance, such as Parasoft C/C++test and Clang Static Analyzer. The SARIF format standardizes the analysis of issues, rules, severities, and code locations, making it easier for projects that rely on multiple tools to manage and review findings directly alongside their source code. Users can import SARIF reports into CLion, allowing them to navigate findings, group results by tool and rule, and maintain the triage process within their development workflow. This integration means that reports from standards like MISRA, AUTOSAR, CERT C/C++, and ISO 26262 can be accessed and managed more conveniently within CLion, enhancing the efficiency of the development process.
May 20, 2026
385 words in the original blog post.
JetBrains supports international employee relocation to build a diverse and talented global team, emphasizing the importance of a smooth transition for new hires. The company provides comprehensive relocation support, including logistics coordination, immigration assistance, and settling-in services, while maintaining regular communication with newcomers to ease their transition into a new country. The relocation process involves several phases, from initial orientation and immigration procedures to practical logistics and settling in, with local specialists and HR teams offering guidance throughout. JetBrains also fosters a welcoming environment through onboarding events, a buddy system, and community networks, ensuring employees feel supported and integrated into their new roles and surroundings. The relocation journey varies in duration, typically taking 2-4 months, and JetBrains aims to make the experience manageable and rewarding, ultimately helping employees focus on their new roles rather than bureaucratic challenges.
May 20, 2026
1,051 words in the original blog post.
Profiling in Go is facilitated by the standard library's pprof tool, which enables developers to analyze and visualize software performance by sampling call stacks and generating reports. Despite its effectiveness, some developers avoid profiling due to its complexity or because typical Go services perform adequately without it. Profiling is crucial for identifying CPU bottlenecks, memory issues, and concurrency problems, enhancing both developer and user experiences. The main profiling types in Go include CPU, heap, allocs, mutex, block, and goroutine profiles, each providing insights into different aspects of program performance. Tools like GoLand simplify the profiling process by offering an integrated environment to collect and inspect profiles easily, eliminating the need for remembering commands and facilitating a smoother transition between code and profiling data. Go profilers, such as runtime/pprof and net/http/pprof, track program performance by sampling call stacks, while GoLand additionally offers a user-friendly interface to manage and visualize profiling data effectively.
May 20, 2026
4,386 words in the original blog post.
Kotlin, designed with a focus on developer productivity and pragmatism, has shown tangible benefits in reducing development time compared to Java, according to a comprehensive study by JetBrains Research. This study analyzed development cycles of over 320,000 developers, revealing that Kotlin developers completed tasks 15%-20% faster than their Java counterparts, across small, medium, and large tasks. The language's design features such as data classes, null safety, and coroutines contribute to more readable and maintainable code, which becomes increasingly valuable as more development tasks shift toward reviewing and integrating AI-generated code. Over a 20-month period, Kotlin projects demonstrated minimal slowdown in development speed, unlike Java projects, which experienced a significant increase in cycle time as codebases grew. These findings suggest that Kotlin's advantages in readability and maintainability enhance not only immediate productivity but also long-term project efficiency, making it an appealing choice for modern software development, especially in environments where AI and agentic workflows are prevalent.
May 20, 2026
1,847 words in the original blog post.
The JetBrains Course Creators Program aims to bridge the gap in online programming education by integrating hands-on coding practice directly into JetBrains IDEs, enhancing the learning experience beyond traditional video-based courses. This initiative is designed for educators and course creators on platforms like Udemy, Coursera, LinkedIn Learning, and others, allowing students to engage with real coding exercises in professional development environments. By partnering with JetBrains, educators can offer practical coding experiences, including writing, running, and debugging code, which are essential skills for internships and developer roles. The program provides resources such as product access, technical guidance, and promotional support to help educators enhance their courses and grow their audience. Integration into JetBrains IDEs is streamlined, requiring minimal course reconstruction, and can be completed within weeks, while alternative collaboration opportunities are also available for those not ready for full integration.
May 19, 2026
804 words in the original blog post.
A career transition from a Big 4 firm to an in-house role at a tech company like JetBrains offers finance professionals a shift from advisory roles to decision-making positions, providing opportunities for deeper business involvement and ownership of projects. While the Big 4 firms are known for their structured environments and steep learning curves, which equip professionals with strong technical skills and adaptability, in-house positions demand independent decision-making and comfort with ambiguity due to their less hierarchical nature. Former consultants Nadija Katzová, Mariia Afonina, and Jean-Paul Straetmans, who transitioned to JetBrains, highlight the appeal of a more sustainable work pace, opportunities for cross-functional collaboration, and the ability to see the tangible impact of their work. They emphasize the importance of being prepared for the challenges of less structure and the necessity of building new support systems, but they also point out the rewards of increased autonomy, real ownership, and the chance to influence long-term business outcomes. JetBrains provides a dynamic environment that values expertise and encourages initiative, making it an attractive option for those seeking a balance between complexity and a manageable workload.
May 19, 2026
1,368 words in the original blog post.
Artificial intelligence is rapidly advancing, with AI agents built on large language models (LLMs) now playing significant roles in various real-world applications. These agents, which can function autonomously or in multi-agent systems, are increasingly used for specialized tasks such as data analysis and customer support. The evaluation of AI agents and their underlying LLMs is crucial to ensure their effectiveness and reliability. LLM evaluation focuses on the model's capabilities and potential risks, using metrics like hallucination rates and toxicity scores to gauge accuracy and safety. Observability, on the other hand, offers real-time insights into an agent's internal processes, helping to monitor its operational health. Advanced evaluation metrics assess not only the final output but also the decision-making processes of AI agents, including task completion rates and tool usage correctness. PyCharm's integration with Hugging Face and AI Agents Debugger facilitates the evaluation and monitoring of AI systems, providing tools to track reasoning steps and performance metrics. Combining offline and online evaluation methods, along with human-in-the-loop oversight, can enhance the reliability and scalability of AI agents in production environments.
May 19, 2026
4,386 words in the original blog post.
Kotlin Multiplatform is introducing a new default project structure to enhance clarity, align with conventions from other build systems, and accommodate changes in Android Gradle Plugin 9.0. The updated structure separates shared code into a distinct Kotlin Multiplatform library module and designates specific application modules for each platform, such as androidApp, desktopApp, and webApp, to streamline configuration and responsibilities. This change addresses previous issues where the composeApp module handled multiple responsibilities and included complex configurations. The new structure also adapts to different configurations, such as projects with native UI or server-side components, by adding sharedLogic and sharedUI modules as needed. While existing projects are not required to adopt this structure, updates are necessary for Android projects due to AGP 9.0 requirements. Tools and resources are available to guide developers through this transition, ensuring ease of modularization and consistency across different configurations.
May 15, 2026
1,069 words in the original blog post.
Compose Multiplatform 1.11.0 introduces several enhancements, notably improving the iOS and web experiences and refining UI testing approaches. Noteworthy updates include an experimental native text input implementation for iOS that enhances precision and native gestures, concurrent rendering now enabled by default for performance benefits, and upgraded v2 ComposeUiTest APIs for more predictable testing on non-Android targets. Additionally, scrolling performance on web targets has been significantly improved to match the responsiveness of native platforms. Users are encouraged to update dependencies and explore new APIs, with detailed changes available in the full release notes.
May 15, 2026
468 words in the original blog post.
IntelliJ IDEA 2026.1.2 has been released, offering a range of fixes and improvements to enhance user experience. The update can be accessed from within the IDE, via the Toolbox App, or through snaps for Ubuntu users, with a download option available on the website. Key fixes include the ability to open projects correctly via .ipr files generated by the Gradle idea task, corrected indentation for Java ternary expressions with chained method calls, and resolved issues where pressing Alt+Enter on Windows inadvertently opened the context menu. Additional improvements include the proper functioning of live templates with groovyScript, the ability to drag and drop code without it disappearing, and the option to open diffs in external tools by double-clicking a file in the Commit tool window. Furthermore, the update addresses illegal character errors reported by the MCP Server for projects with spaces in their paths, ensures workspaces function correctly, and resolves several IDE freezes. For more detailed information about the resolved issues, users are encouraged to refer to the release notes and report any new bugs to the issue tracker.
May 15, 2026
265 words in the original blog post.
In the context of the evolving landscape of AI in software development, a community survey has been launched to better understand how Kotlin developers are integrating AI tools into their workflows, such as code completion and AI chat assistants. The survey aims to gather insights on the effectiveness, challenges, and future opportunities for AI-assisted development with Kotlin, inviting developers to share their experiences and expectations. Participants have the chance to win prizes like a USD 50 Amazon Gift Card or a six-month JetBrains All Products Pack subscription. Additionally, attendees of KotlinConf 2026 who complete the survey are encouraged to visit the registration counter for a small thank-you gift.
May 15, 2026
226 words in the original blog post.
In PyCharm 2026.1.2, the integration of Pyrefly as an external type provider through the Language Server Protocol (LSP) significantly enhances the IDE's code insight features by delivering faster and more efficient type-checking capabilities. Pyrefly, developed by Meta, is a next-generation Python type checker built in Rust, offering improved performance, cross-platform portability, and robust handling of large-scale Python codebases compared to its predecessor, Pyre. Once enabled, Pyrefly supports essential IDE functionalities such as type inference and diagnostics, quick documentation, and inlay hints with immediate error reporting, although it currently lacks support for certain configurations like Docker and multi-module projects. Users can switch to Pyrefly via the Type widget in PyCharm, where its speed and efficiency markedly outperform the built-in type engine, thus facilitating better performance and scalability for developers managing complex Python projects.
May 15, 2026
689 words in the original blog post.
PyCharm 2026.1.2 introduces integration with Pyrefly, Meta's new Python type checker, leveraging the Language Server Protocol (LSP) to enhance code insight features like type inference, error checking, and quick documentation. Built in Rust, Pyrefly offers faster performance and better cross-platform portability compared to its predecessor, Pyre. This integration enables PyCharm to perform code analysis more efficiently, especially for large-scale Python projects, by using Pyrefly as an external type provider. This boosts the IDE's ability to deliver immediate diagnostics and code intelligence. While Pyrefly excels in speed, it currently supports local interpreter configurations with plans for expanding compatibility to other configurations like Docker and WSL. Users can switch to Pyrefly in PyCharm to experience immediate performance improvements, although a noted limitation is that it occasionally misses some errors in complex codebases.
May 15, 2026
686 words in the original blog post.
Compose Multiplatform 1.11.0 introduces several enhancements to improve the iOS and web experience, including native text input on iOS for more precise caret movement and native gestures, and concurrent rendering enabled by default to boost performance. The update also improves Compose UI testing on non-Android targets by adopting v2 ComposeUiTest APIs, which use the StandardTestDispatcher for more predictable coroutine execution and allow custom coroutine contexts. Additionally, scrolling performance on web targets has been significantly improved, aligning it more closely with native experiences. Users are encouraged to update their dependencies and explore the new features, with further details available in the full release notes.
May 15, 2026
456 words in the original blog post.
The Kotlin Multiplatform project structure has been updated to provide modules with clearer responsibilities and better alignment with modern build conventions, reflecting changes in the Android Gradle Plugin 9.0. This new structure, now implemented in the Kotlin Multiplatform wizard and official documentation, separates shared code into a distinct module and designates individual application modules for each platform, such as Android, desktop, and web. This approach resolves the previous structural complexity where a single module contained both shared libraries and application-specific configurations, particularly addressing the asymmetry in iOS development that required separate iOS folders. The updated structure supports modularity, allowing projects to easily expand from a single multiplatform module to multiple ones, and accommodates different configurations, including the use of native UI and server-side Kotlin. While existing projects are not obligated to adopt this new structure, compliance with Android Gradle Plugin 9.0 changes is necessary, and guidance is available to assist migrations.
May 15, 2026
1,064 words in the original blog post.
PHPverse 2026, a community-inspired professional event for PHP developers, is scheduled for June 9, 2026, and will showcase influential figures from the PHP ecosystem sharing insights on the modern evolution of the PHP language and associated tools and frameworks. Hosted by Brent Roose and Nuno Maduro, the event will be streamed live on YouTube with English subtitles and feature keynotes by notable speakers like Elizabeth Barron and Jeffrey Way. Building on the success of its inaugural event in 2025, which marked PHP's 30th anniversary and attracted over 15,000 viewers globally, PHPverse 2026 aims to continue fostering connections and knowledge sharing within the vibrant PHP community. Attendees can expect a day filled with live Q&A sessions, special announcements, and opportunities to engage with the speakers. The event is free, open to everyone, and offers the flexibility to attend live or access recordings afterward. Participants are encouraged to use the #PHPverse hashtag to share their experiences and help expand the conversation about PHP's future.
May 15, 2026
734 words in the original blog post.
IntelliJ IDEA 2026.1.2 has been released, bringing several important fixes aimed at improving user experience and functionality. Key updates include the ability to open projects correctly via .ipr files generated by the Gradle idea task, fixed indentation for Java ternary expressions with chained method calls, and the resolution of unexpected behavior when pressing Alt+Enter on Windows. Additionally, live templates with groovyScript are functioning as expected, issues with code disappearing when dragged and dropped have been addressed, and users can once again open a diff in an external tool via the Commit tool window. The update also resolves illegal character errors reported by the MCP Server for projects with spaces in their paths and ensures workspaces are operating correctly. Several instances of IDE freezes have been resolved, enhancing the overall stability and performance of the platform. Users can update to this version through various methods, including the IDE itself, the Toolbox App, or by downloading from the website, and are encouraged to report any bugs they encounter.
May 15, 2026
267 words in the original blog post.
In the rapidly evolving landscape of AI-assisted software development, the integration of AI tools like code completion and autonomous coding agents is transforming how developers work, particularly with languages like Kotlin. To explore the effectiveness and challenges of these tools in the Kotlin community, a survey has been launched to gather insights from developers about their experiences and expectations. By participating, developers not only contribute valuable feedback to shape the future of Kotlin in the AI era but also stand a chance to win prizes such as an Amazon gift card or a JetBrains subscription. Additionally, attendees of KotlinConf 2026 are encouraged to engage with the survey and visit the event's registration counter for a token of appreciation.
May 15, 2026
216 words in the original blog post.
In an exploration of the concept of "friction-maxxing," Clara Maine discusses the value of intentionally embracing challenges and difficulties in learning, particularly in the context of coding and technical skills. Coined by sociologist Kathryn Jezer-Morton, friction-maxxing is the idea of increasing "friction" in our lives to enhance resilience, intelligence, and happiness, counteracting the trend of smoothing out life's challenges with technology and convenience. Maine connects this idea with her experiences at JetBrains Academy, where she highlights the importance of effort and failure in learning, suggesting that overcoming difficulties can lead to deeper understanding and skill mastery. The text critiques the modern approach of overly simplifying education with AI tools, arguing that genuine learning requires active engagement and the development of computational thinking. Maine emphasizes the significance of self-regulation and managing the emotional challenges of learning, suggesting that educational success may lie more in integrating existing knowledge than in acquiring new information, and calls for educational systems to explicitly teach self-regulation strategies to better prepare students for the evolving job market.
May 13, 2026
1,488 words in the original blog post.
PyCharm 2026.1.1 introduces built-in support for uv, Poetry, and Hatch workspaces, currently in Beta, to streamline the management of massive Python codebases with interdependent projects. This new functionality enables automatic management of dependencies and environments across entire workspaces by deriving their structure and dependencies directly from pyproject.toml files, significantly reducing manual configuration. PyCharm now offers an integrated experience for managing multi-package setups in uv workspaces, with features like automatic environment configuration, dependency visualization, and import management. The IDE prioritizes a zero-config approach, automatically configuring compatible environments for projects and providing quick-fixes for discrepancies between code imports and environment settings. While PyCharm automates backend processes, such as uv sync, it maintains transparency through a Python Process Output tool window, allowing users to track executed commands and analyze error logs. The same workflow applies to Poetry and Hatch workspaces, with environment tool selection based on specifications in the pyproject.toml file, and further improvements are planned based on user feedback.
May 13, 2026
759 words in the original blog post.
Kotlin is undergoing a significant evolution in its approach to destructuring, shifting from a position-based to a name-based system. This change introduces new syntax options, such as using "val" inside parentheses for name-based destructuring and square brackets for positional destructuring, which are currently experimental and can be enabled with specific compiler arguments. The transition aims to address issues related to refactoring, abstraction, and inadvertent errors due to property order mix-ups, by ensuring that properties are accessed by their stable names rather than their order. The compiler provides migration tools and warnings to aid developers in adapting their code, and while name-based destructuring is set to become the default in future Kotlin versions, the plan includes a gradual rollout with substantial time for the community to adjust. This approach maintains backward compatibility with existing data classes while preparing for advanced features like multi-field value classes that will only support name-based destructuring.
May 13, 2026
1,437 words in the original blog post.
In the context of an optimization-driven culture, the concept of "friction-maxxing" emerges as a countercultural lifestyle advocating for the value of embracing challenges and discomfort to enhance intelligence, happiness, and resilience. This notion aligns with educational research that emphasizes the importance of tackling difficult tasks, such as coding, to develop critical and computational thinking skills. Despite the proliferation of resources aimed at making coding more accessible, the steep learning curve persists, partly due to a cultural belief in its inherent difficulty. The article argues that true learning involves embracing failure and discomfort, activating the brain's neuroplasticity through active engagement, rather than relying solely on passive absorption of information. It also highlights the significance of self-regulation strategies to manage the emotional challenges of learning, underscoring the importance of integrating new knowledge through reflection and rest, rather than continuously seeking more information.
May 13, 2026
1,488 words in the original blog post.
PyCharm 2026.1.1 has introduced beta support for uv, Poetry, and Hatch workspaces, catering to companies and open-source teams that manage shared code across multiple services. This update automates dependency management and environment configuration, using pyproject.toml files to detect workspace structures and dependencies, thereby reducing manual setup. The IDE can automatically configure the Python SDK, monitor environment health, and provide quick-fixes for missing dependencies or imports. It remains transparent by allowing users to track executed commands and address synchronization errors. The same workflow applies to Poetry and Hatch workspaces, with PyCharm selecting the environment tool based on configurations in pyproject.toml. This feature is opt-in, with future expansion plans for UI enhancements and functionality based on user feedback.
May 13, 2026
754 words in the original blog post.
Kotlin is introducing a significant shift in its destructuring mechanism by moving from position-based to name-based destructuring, with the new syntax currently available in experimental form. This change aims to enhance the reliability and flexibility of destructuring, particularly when working with data classes, by allowing developers to extract properties by name rather than relying on their position. The new syntax enables the use of "val" inside parentheses for name-based destructuring and square brackets for positional destructuring, facilitating clearer and more maintainable code. The transition is gradual, with tools and compiler arguments provided to assist developers in migrating their code, and the feature is set to become stable by version 2.5.0, with a full transition expected by version 2.7.0. Despite the changes, Kotlin will continue to support position-based destructuring for certain use cases, such as collections and tuple-like structures, while also preparing for the introduction of multi-field value classes that will utilize name-based destructuring exclusively.
May 13, 2026
1,436 words in the original blog post.
JetBrains released a retrospective on the significant events of 2025, highlighting their commitment to supporting developers and organizations in the rapidly evolving software development sector. The company focused on adapting to industry transformations, particularly with the rise of AI, by enhancing tools and experiences aligned with developers' evolving needs. The past year witnessed significant milestones in product development, business activities, and community support, with notable advancements in AI-assisted development and increased corporate adoption of JetBrains solutions. For more detailed insights into their achievements and key moments from the past year, readers are encouraged to explore the full annual highlights.
May 13, 2026
216 words in the original blog post.
JetBrains is focused on integrating AI into their IDEs without disrupting traditional coding workflows, allowing developers to choose between conventional and AI-assisted methods for writing code. The company aims to maintain compatibility with existing workflows while avoiding vendor lock-in by supporting various activation methods such as subscriptions, BYOK, and ACP agents. JetBrains emphasizes the importance of user responsibility for the code generated by AI, ensuring that all code undergoes the same review and management process as manually written code. Their strategy includes creating an environment where AI and conventional methods coexist, enhancing productivity without compromising the foundational elements of code intelligence, refactoring, debugging, and project management. The company values community feedback and prioritizes long-term practicality over fleeting trends in AI-driven workflows, ensuring that users have the freedom to select their preferred approach while maintaining control and understanding of their codebase.
May 13, 2026
286 words in the original blog post.
The Qodana 2026.1 release introduces significant updates, including the stable release of the C/C++ linter for production use and the launch of an Early Access Program (EAP) for Rust, reflecting growing interest in Rust for infrastructure and performance-sensitive systems. It includes over 150 inspections for Rust, such as dead code and unsafe code checks, while also supporting conditional compilation and multiple workspaces. Additionally, new code inspections have been added for Kotlin, Python, and C#, targeting issues like suspicious uses of callable references in Kotlin, coroutine conditions in Python, and short-lived HttpClient instances in C#, which can lead to subtle production bugs. These enhancements aim to improve code quality and early detection of potential issues across various languages, encouraging users to update to the latest version to utilize these tools.
May 12, 2026
894 words in the original blog post.
JetBrains' dotInsights newsletter provides an overview of recent developments in the .NET and software development community, highlighting various tools, techniques, and discussions relevant to developers. It features links to resources like Gui Ferreira's exploration of AI-driven specification writing, Nick Chapsas' tips for accelerating AI development workflows, and Derek Comartin's insights on testable code. The newsletter also covers a range of .NET-specific topics such as building animations in .NET MAUI, optimizing byte[] allocations, and understanding EF Core query translations. Additionally, it discusses broader issues like the impact of AI on coding and the importance of code quality in AI-assisted environments. JetBrains introduces Junie, a new AI coding agent for Visual Studio, as part of its efforts to promote an open AI ecosystem and break vendor lock-in. The newsletter also invites readers to explore JetBrains' latest news, engage in social posts, and subscribe for updates.
May 12, 2026
535 words in the original blog post.
TeamCity 2026.1 introduces several new features, including the TeamCity CLI for terminal access and AI integration, support for the Model Context Protocol (MCP) to enhance AI tool interoperability, and improvements to Pipelines with enhancements in YAML and Kotlin DSL configurations. The release also addresses a high-severity security vulnerability, CVE-2026-44413, affecting TeamCity On-Premises, urging users to update to the latest version or apply a security patch plugin. Additionally, the AI Assistant is now available in Enterprise trial accounts, and SAML authentication support is bundled to improve single sign-on capabilities. The update also brings improvements to the Pipeline Run page, job build features, and the ability to define upstream dependencies, allowing for more streamlined and manageable workflows. The release aligns with a new naming convention for TeamCity versions and emphasizes ongoing enhancements to user experience and security.
May 12, 2026
1,498 words in the original blog post.
The PhpStorm 2026.2 Early Access Program (EAP) has commenced, offering users the chance to explore and provide feedback on upcoming features before the official release. This program is free and allows users to experiment with new functionalities in real workflows, which significantly influences the final release. The main focus areas for this release include enhancing remote development capabilities, improving PHPDoc-based generics comprehension, and overall performance and stability enhancements, such as reducing startup and indexing times. Users can access these EAP builds weekly without needing a license and can maintain both their stable and EAP versions concurrently. Access to these builds can be managed through the Toolbox App or by enabling automatic updates via IDE settings, ensuring users can seamlessly integrate feedback into the development process.
May 12, 2026
277 words in the original blog post.
In a detailed exploration of the impact of AI on software development, Delphine Massenhove highlights that AI amplifies existing team dynamics rather than leveling them, enhancing productivity for high-performing teams and exacerbating weaknesses in others. A study by GitClear demonstrated that regular AI users produce significantly more sustainable code, yet the increased output also reveals a need for improved code review processes and discipline in managing technical debt. Moreover, the adoption of AI tools, while boosting individual productivity, introduces challenges such as longer review times and increased complexity, calling for refined processes rather than expanded teams. The article emphasizes the importance of nurturing developer judgment, particularly among junior engineers, to ensure AI's productivity gains do not come at the cost of essential skills. It advocates for strategic flexibility in tool usage, underpinned by a stable structural model like JetBrains IDEs, which supports diverse AI tools while maintaining code integrity.
May 12, 2026
1,985 words in the original blog post.
JetBrains has launched the Early Access Program (EAP) for ReSharper and .NET Tools 2026.2, focusing on integrating AI agents into Visual Studio to provide developers with more flexibility and control over their AI tools. The initiative introduces Junie, an AI coding agent designed to work within the ReSharper environment as part of the broader Agent Client Protocol (ACP) framework, enabling users to explore local, remote, and in-house AI agents without vendor lock-in. This initial EAP aims to test the integration's foundational aspects, allowing Junie to autonomously write, edit, and refactor code, perform terminal operations, and offer project-specific insights. While early-stage limitations exist, such as basic UI and lack of deep backend integration, JetBrains emphasizes user feedback to refine and expand support for various AI agents in ReSharper, aiming for a truly open ecosystem. Participation in the EAP is free, although using AI models requires resources, prompting users without a JetBrains AI subscription to start with a trial that supports comprehensive exploration of Junie's capabilities.
May 11, 2026
1,140 words in the original blog post.
A high-severity security vulnerability, identified as CVE-2026-44413, has been discovered in TeamCity On-Premises, potentially allowing authenticated users to expose parts of the server API to unauthorized users. This issue affects all versions up to 2025.11.4 and has been resolved in version 2026.1. Users are strongly encouraged to update to the latest version or apply a security patch plugin if upgrading is not possible. TeamCity Cloud is not impacted, and no action is required for its users. The vulnerability, which was confidentially reported by Martin Orem, involves post-authentication privilege escalation and can be mitigated by securing internet-facing servers with additional layers such as VPNs. Users are advised to restrict network access to essential ports and run servers on dedicated hosts to prevent exploitation. For support and further guidance, users can contact the TeamCity Support team.
May 11, 2026
704 words in the original blog post.
Code maintainability is a crucial aspect of software development, emphasizing the importance of creating code that is clean, readable, and easy to modify without unintended consequences, thereby ensuring a seamless development process. It allows for a smoother software lifecycle, enabling developers to efficiently implement fixes, updates, and enhancements, and is considered a core element of the Software Development Life Cycle (SDLC). Effective code maintainability involves several elements, with static code analysis being a key factor in enforcing consistent coding standards and improving code quality and readability. Good maintainability facilitates faster development, easier error identification and fixing, efficient onboarding of new developers, and overall scalability by ensuring that the codebase remains stable and reliable. Characteristics of maintainable code include readability, modularity, testability, consistency, and simplicity, which collectively contribute to sustainable software that minimizes technical debt. Techniques for ensuring maintainability include using consistent naming conventions, adding useful comments, maintaining documentation, automating testing, and conducting static code reviews. Static code analysis plays a significant role in identifying coding weaknesses, encouraging simpler code, enforcing standards, and reducing technical debt, ultimately saving time, effort, and money throughout the software's lifecycle.
May 11, 2026
1,236 words in the original blog post.
JetBrains is committed to supporting both traditional and AI-assisted coding workflows within its Integrated Development Environments (IDEs), ensuring that neither hinders the other. The company emphasizes a balanced approach where developers can opt for classic coding methods or integrate AI tools, such as autocomplete and agent-driven code generation, without compromising the core IDE experience. JetBrains aims to avoid vendor lock-in by allowing multiple ways to incorporate AI, including subscriptions, API keys, and external agents via the Agent Client Protocol (ACP). The focus remains on maintaining code quality and accountability, with the IDE providing visibility and control over both human- and AI-generated code. JetBrains values community feedback and prioritizes long-term utility over short-lived trends, reinforcing the IDE as the central hub for reviewing and owning code, regardless of the chosen workflow.
May 11, 2026
1,111 words in the original blog post.
The GoLand 2026.2 Early Access Program (EAP) has begun, offering developers a chance to explore and influence the upcoming features of the GoLand IDE. This program allows participants to try new functionalities, such as performance insights and memory optimization, while providing feedback that shapes the final release. Key features include a consolidated Go Performance Optimization tool window for profiling, escape analysis to detect unnecessary heap allocations, and struct layout optimization for improved memory usage. Developers can monitor CPU and memory usage in real time and benefit from automatic run/debug configurations to streamline project onboarding. Feedback from participants is encouraged to guide further enhancements throughout the EAP cycle.
May 11, 2026
1,070 words in the original blog post.
Rider 2026.2's Early Access Program (EAP) has commenced, offering users a preview of upcoming features with notable performance enhancements, particularly in Roslyn integration for improved branch switching in large solutions. These optimizations include reducing requests, implementing batching, and minimizing data transfer, resulting in branch switching speeds that are up to 100 times faster in some scenarios. For game developers, Rider has reworked asmdef reference handling for Unity projects and improved GDScript support for Godot, including spellchecking. Azure Functions support is being integrated into Rider from the Azure Toolkit plugin, allowing local development and debugging within Docker containers. Aspire projects benefit from enhanced file-based AppHosts and improved dev certificate validation. Users are encouraged to participate in the EAP to test these features and contribute feedback for further refinement.
May 11, 2026
800 words in the original blog post.
The article by Pavel Fatin discusses the concept of highlighting complexity in Scala programming and provides strategies to make code more efficient for highlighting, which can lead to better system performance and responsiveness. It emphasizes that while algorithmic complexity is a common consideration in software development, developers often overlook the impact of highlighting complexity, which affects how quickly an Integrated Development Environment (IDE) can process code for features like syntax highlighting. To mitigate this, the article suggests several best practices, such as dividing code into modules, placing classes in separate files, defining classes within packages rather than objects, and using specific imports instead of wildcards. It also encourages programmers to consider highlighting complexity alongside cognitive and algorithmic complexities to enhance both the developer experience and system performance. These principles not only improve the efficiency of code highlighting but also contribute to cleaner, more maintainable code, and they apply to AI-generated code as well. The Scala team at JetBrains continues to improve the IntelliJ IDEA and Scala plugin performance, and they recommend developers balance various complexities for optimal results.
May 07, 2026
2,933 words in the original blog post.
Python Unplugged on PyTV, held on March 4, 2026, was a fully online community conference that successfully recreated the vibrancy of an in-person event, drawing thousands of live viewers and many more on-demand. The event featured live talks, expert panels, and interactive sessions, with speakers from the Python ecosystem gathering in Amsterdam, Python's birthplace. Key discussions included Python's evolution beyond a beginner-friendly language, the continuing importance of its community, and the dual impact of AI on open source and developer workflows. AI's role in transforming development practices, the expansion of the open-source AI ecosystem, and the ongoing relevance of frameworks like Django were also highlighted. The conference underscored Python's adaptability and innovation, driven by its community's collaborative spirit, as it navigates contemporary challenges and opportunities in AI and open-source development.
May 07, 2026
1,907 words in the original blog post.
The MPS 2026.1 Early Access Program (EAP) has begun, offering an updated build that includes various enhancements and bug fixes. Key improvements involve the transition to the IntelliJ Platform 2026.1, JDK 25, and Kotlin 2.3, alongside restored KLib-based Kotlin stubs support. The EAP now features advanced natural language checking for proper capitalization in string values, the ability to split binary operations across multiple lines, and a new read-only-inspector style for editor cells. Build Language has been refined to handle transitive dependencies more efficiently, while the migration process benefits from more reliable dependency tracking. Java stubs have been significantly improved, addressing long-standing issues with BaseLanguage stubs for imported Java files. The project lifecycle has been modernized with a new mechanism for managing MPSProject activities, and Wayland is now the default display protocol on Linux systems, enhancing integration and stability. The EAP build aims to improve the overall user experience and maintain compatibility across different environments.
May 07, 2026
1,057 words in the original blog post.
The Kotlin Ecosystem Mentorship Program (KEMP) pilot successfully connected mentors and mentees to collaborate on real Kotlin open-source projects, resulting in meaningful community contributions. Out of ten selected pairs, four completed the two-month program, with one pair winning a trip to KotlinConf 2026 in Munich. The winning pair, comprising mentor Ruslan and mentee Clare Kinery, focused on the Android client of BitChat, where Clare made significant UI and UX improvements. The program highlighted the value of open-source collaboration, offering mentees hands-on experience and mentors fresh contributions while improving onboarding processes. The initiative received strong community interest, with 80 mentee and 29 mentor applications, and plans to continue based on the positive feedback and outcomes.
May 07, 2026
648 words in the original blog post.
Remote development is transforming how plugins for JetBrains IDEs are built, as it introduces a client-server model where the frontend client interacts with a backend that may run on different machines or in the cloud. This approach enhances remote environments, security, and flexible workflows, necessitating that plugin developers consider the optimal location for each part of their plugin. The new architecture requires a focus on frontend, backend, and shared functionalities, ensuring that each component operates on its appropriate side to prevent latency issues. JetBrains provides guidance for developing split-mode-aware plugins, explaining the necessary terminology, architecture, and practical steps, including structuring modules and connecting frontend and backend components. Additional resources, such as a high-level video overview, a plugin template, detailed documentation, and access to the JetBrains Platform forum, are available to support developers in adapting to this new development paradigm.
May 07, 2026
367 words in the original blog post.
Since 2017, the Developer Ecosystem Survey has been gathering insights from developers globally to track industry evolution and predict future trends, and the 2026 edition marks its tenth anniversary. Over the years, the survey has documented significant changes like the rise of Kotlin and the integration of AI coding tools into everyday development practices. The survey attracts tens of thousands of participants annually, providing a comprehensive overview utilized by researchers, industry analysts, and tool developers. Participants are encouraged to share their experiences in exchange for a chance to win prizes such as a MacBook Pro, Amazon gift cards, and JetBrains subscriptions. The survey results are shared through detailed infographics and reports, with anonymized data made publicly available for further exploration.
May 06, 2026
357 words in the original blog post.
IntelliJ IDEA 2025.3.5 has been released, featuring performance enhancements specifically for Spring projects by preventing searches for declared Spring beans during typing or completion, which optimizes code completion in Spring-based projects. Users can update to this version through the IDE, the Toolbox App, or snaps for Ubuntu, and it is also available for download on the website. The release notes offer a detailed list of fixes, and users are encouraged to report any issues via the issue tracker.
May 06, 2026
138 words in the original blog post.
The Developer Ecosystem Survey 2026, marking its tenth edition, invites developers worldwide to contribute insights into the evolving software development landscape. Since its inception in 2017, the survey has captured the transformative shifts in the industry, including the emergence of Kotlin and the integration of AI coding tools into everyday development. Gathering data from tens of thousands of participants, the survey provides a comprehensive view of the tools, technologies, and challenges shaping modern development, benefiting researchers, analysts, and tool developers alike. Participants are encouraged to share their experiences, with the opportunity to win prizes such as a MacBook Pro, Amazon gift cards, and JetBrains subscriptions. The survey results will be published in detailed infographics and reports, with anonymized raw data available for further exploration. The initiative emphasizes the importance of widespread participation to accurately reflect the current state of software development and invites developers to engage by sharing referral links for additional rewards.
May 06, 2026
354 words in the original blog post.
Dogfooding, the practice of using one's own products to improve them, is a central strategy at JetBrains for developing tools such as IntelliJ IDEA, YouTrack, and Rider. By integrating these tools into their daily workflows, JetBrains employees proactively identify and address issues, fostering a direct and immediate feedback loop that enhances software quality. This approach has transformed products like Rider from unstable experiments into world-class IDEs by allowing teams to experience firsthand the challenges and needs of developers. Dogfooding not only accelerates problem-solving but also cultivates a sense of ownership and empathy among team members, as they are both the creators and users of their software. This culture of continuous internal testing ensures that JetBrains tools are refined and robust, meeting the high standards expected by users and keeping the company connected to its mission of building meaningful, developer-centric solutions.
May 05, 2026
1,089 words in the original blog post.
The May 2026 edition of "AI Java Kotlin News" offers a comprehensive overview of the latest developments in AI, Java, and Kotlin, featuring insights from industry experts like Emily Bache and highlighting the significant trend of AI coding agents replacing traditional hand-coding practices. The publication emphasizes the importance of mastering new skills in AI tool design, with references to resources by Birgitta Böckeler and Chris Parsons, alongside discussions on the ethical considerations of using AI in software development. The issue also covers updates in Java, including Java 26 and JDK 27, and explores various technical topics such as test-driven development, AI orchestration, and the challenges of integrating AI with Java frameworks. Additionally, it provides information about upcoming conferences and events, offering a platform for developers to engage with the latest innovations and community discussions, while also touching upon cultural aspects and the evolving landscape of software development in the AI era.
May 05, 2026
1,265 words in the original blog post.
The rise of AI coding tools has significantly increased the volume of code arriving for review, presenting new challenges for engineering leaders as traditional code review processes struggle to keep up. With developers using AI tools in an ad hoc manner, these tools have introduced unique error patterns and a distinct error profile, including unused constructs and higher-risk security vulnerabilities, which are not common in human-written code. This influx of AI-generated code has led to a 7.2% reduction in delivery stability as it places a greater burden on human reviewers who must now contend with larger changesets and more complex error profiles. Automated structural and static analysis before code reaches human reviewers can alleviate some of this burden, as evidenced by companies like Google and Uber, which have implemented automated verification systems to reduce the need for human intervention and maintain stability. While many development environments rely on language-by-language approximations, comprehensive structural analysis at an organizational level is crucial for maintaining code quality, with tools like JetBrains IDEs and Qodana offering solutions for pre- and post-pipeline checks to protect reviewers' capacity and judgment.
May 05, 2026
1,082 words in the original blog post.
The text discusses leveraging AI Agent Skills to address the challenge of debugging flaky tests, which are tests that inconsistently pass or fail without changes to the code or test itself, thereby wasting resources and complicating bug identification. Using a Spring Boot project as an example, the article details a method of using AI, traditional developer tools, and coverage analysis to identify the root cause of flakiness by comparing code execution paths from successful and failing test runs. By modifying IntelliJ IDEA's coverage tool to provide detailed execution counts, developers can pinpoint the exact lines where execution diverges, indicating the source of the test's unreliability. The process is then packaged into a reusable AI Skill, allowing automated detection and resolution of flaky tests, demonstrating the broader potential of AI Skills in simplifying complex programming problems through structured, repeatable procedures.
May 04, 2026
1,967 words in the original blog post.
April's Kotlin Roundup highlights significant updates and events in the Kotlin community, including the announcement of the Golden Kodee finalists who will be celebrated at KotlinConf 2026 in Munich. The conference will gather over 2,000 developers and will be livestreamed for those unable to attend in person. Recent Kotlin releases, such as 2.4.0-Beta2 and IntelliJ IDEA 2026.1, offer language and performance improvements. The post also explores Kotlin Multiplatform's business value and features new learning resources like the Kotlin Professional Certificate on LinkedIn Learning. Additional updates include Amper 0.10.0's enhancements, Koog's JVM ecosystem integration, and a practical post on using Spring Data JPA with Kotlin. Fun and educational tools like the Coroutines Races Guesser Game provide interactive ways to learn Kotlin.
May 04, 2026
884 words in the original blog post.
In the competitive landscape of AI frameworks, both PyTorch and TensorFlow offer distinct advantages suited to different project needs, making the choice between them highly dependent on specific goals. PyTorch, favored in research environments, shines with its intuitive Pythonic API and dynamic computational graphs, allowing for flexible experimentation and natural debugging, which is reflected in its dominance in deep learning research papers. However, its production deployment tools lag behind the more mature infrastructure of TensorFlow, which is designed for enterprise environments with robust support for mobile and edge optimization, as well as extensive MLOps tooling. TensorFlow's steeper learning curve and more complex API are balanced by its established presence in large-scale production systems. Ultimately, PyTorch is ideal for research and projects involving natural language processing and reinforcement learning, while TensorFlow excels in production scenarios, particularly in computer vision applications requiring mobile deployment. Both frameworks have strong community support and continue to evolve, with organizations often leveraging both to capitalize on their respective strengths.
May 04, 2026
1,977 words in the original blog post.
The implementation of IDE-native search tools for coding agents significantly improved performance metrics such as latency and cost without compromising quality. By integrating a prebundled search skill with a unified MCP tool, agents could utilize IDE-specific resources like indices and project models, which shell tools like grep and find cannot access. The new system reduced median latency by 8.33% and P95 latency by 16.44%, while total costs decreased by 5.60% and budget overruns fell by 33.28%. The evaluation used paired delta analysis with tasks conducted both with and without the new tooling, demonstrating statistically significant improvements. The benefits were most pronounced in environments where the existing search capabilities were weak, such as with Codex, which routed 91% of search calls through the new tool. The successful configuration is now being prepared for integration into the IntelliJ IDEA MCP Server, with plans for a default rollout in future AI Assistant plugin updates.
May 04, 2026
1,260 words in the original blog post.
The JetBrains x Codex Hackathon explored the integration of AI coding models within Integrated Development Environments (IDEs), transforming them from simple code-writing platforms into dynamic spaces where developers can direct AI agents and manage their reasoning processes. Among the finalists, innovative projects showcased how AI can enhance coding efficiency and reliability by introducing advanced reasoning capabilities, integrating hardware testing tools, enabling shared session states across devices, and improving security incident responses. The winning entry, Hyperreasoning, proposed a search-based approach where a local model drafts multiple solutions, iteratively refined through testing and feedback, making it competitive against larger models at a lower cost. Other notable projects included Scopecreep, which consolidates hardware testing tools into a single interface, and mesh-code, which facilitates continuity by sharing project states across different machines. SecureLoop aimed to automate and streamline security incident responses, while Pinpoint enhanced frontend development by allowing precise feedback on web elements. Collectively, these projects demonstrated the potential of embedding AI within IDEs to create a more interactive and controlled coding environment, highlighting the transformative impact AI can have on software development workflows.
May 04, 2026
1,033 words in the original blog post.
April's update from JetBrains Academy highlights several new learning opportunities, including a collaboration with DeepLearning.AI on spec-driven development and a beginner-friendly course to build a full-stack chat app. The academy also introduced a Kotlin Professional Certificate in partnership with LinkedIn Learning, offering a path from basics to advanced multiplatform development. Additionally, Angela Yu's 100-Day Python Challenge is now available as an in-IDE course, providing a comprehensive introduction to Python through 100 projects. For those interested in AI and machine learning, there are courses on building AI agents with PyCharm and creating TensorFlow models in Python. The digest also includes insights from research on popular AI coding tools among developers, revealing a trend towards specialized tools for development.
May 01, 2026
553 words in the original blog post.
The recent JetBrains livestream featured a conversation between Vitaly Bragilevsky and Rain, the creator of cargo-nextest, focusing on Rust testing and developer tools. cargo-nextest, a next-generation test runner, is designed to enhance the speed, observability, and reliability of Rust test executions, particularly for large projects and CI pipelines. With its integration in RustRover 2026.1, developers can now manage nextest sessions within the IDE, complete with progress reporting and structured results. Rain's journey into Rust began at Meta while working on a Mercurial server, leading to a deeper involvement with the language. cargo-nextest addresses the limitations of the traditional cargo test by providing faster test runs, better handling of flaky tests, and improved debugging capabilities through features like run recording and Perfetto trace output. It is particularly beneficial for large codebases and complex testing environments, offering extensibility and integration with other tools. Despite the complexity involved in building cargo-nextest, the tool aims to improve the overall developer experience by making test processes more efficient and transparent.
May 01, 2026
1,656 words in the original blog post.