December 2025 Summaries

In March 2024, TeamCity introduced TeamCity Pipelines to simplify CI/CD setup with features like a visual editor and YAML-defined building routines, which received positive feedback. By July 2025, Pipelines were incorporated into TeamCity Enterprise as part of an Early Access Program to evaluate its integration with regular TeamCity servers. By December 2025, TeamCity unified its offerings, integrating Pipelines into TeamCity Enterprise for both Cloud and On-Premises versions, thus discontinuing Pipelines as a standalone product. This integration maintained existing Pipelines users' environments and subscriptions, transitioning them to TeamCity Cloud Enterprise without altering pricing. The unified TeamCity platform now allows users to experience the new Pipelines alongside traditional build configurations and chains, enhancing the overall CI/CD capabilities.

Ruby, a programming language created by Yukihiro "Matz" Matsumoto in 1995, celebrates its 30th anniversary and the release of Ruby 4.0, spotlighting its role in making coding more intuitive and enjoyable with its object-oriented model and dynamic typing. Known for its Principle of Least Surprise, Ruby emphasizes code readability and flexibility, which has fostered a thriving community and led to the development of crucial tools such as Bundler, RSpec, and RuboCop. Over the years, Ruby has evolved through significant milestones, including the introduction of YARV VM in version 1.9, performance enhancements in Ruby 2.x, the achievement of the Ruby 3×3 vision in Ruby 3.x, and new features like the ZJIT compiler in Ruby 4.0. Ruby's influence is significant in the tech world, powering major platforms like GitHub, Shopify, and Airbnb, and remains a popular choice for startups. RubyMine, an IDE by JetBrains introduced in 2009, enhances the Ruby experience by offering advanced tooling and support, reflecting Ruby's ethos of enjoyable and expressive coding. As Ruby enters its fourth decade, the language and its community continue to flourish, driven by passion and creativity, with RubyMine contributing to its ongoing relevance.

The article summarizes a JetBrains livestream featuring Rust expert Herbert Wolverson, who discusses various aspects of the Rust programming language, its learning curve, and its adoption in the tech industry. Key topics addressed include memory management differences between Rust and languages like Java and C#, the language's ownership and borrowing model, and the benefits of Rust's zero-cost abstractions. Wolverson also highlights the importance of learning through building projects and recommends resources such as his books "Hands-On Rust" and "Advanced Hands-On Rust." Additionally, the article touches on Rust's growing adoption in industries like defense and finance, its integration capabilities with other languages via Foreign Function Interface, and its community-driven evolution. Wolverson emphasizes Rust's focus on safety and clarity, particularly through its use of Result and Option types for error handling, and encourages beginners to approach learning Rust through a mix of books, online resources, and practical projects.

Java's introduction of virtual threads has significantly enhanced hardware utilization for parallel I/O-bound operations with minimal code changes, allowing servers to handle millions of threads compared to the few hundred they managed before. This advancement presents challenges for existing Java tooling, such as thread dump viewers and debuggers, which now must manage and display potentially millions of thread rows. Despite these challenges, tools like IntelliJ IDEA have adapted to support virtual threads, offering features like capturing and analyzing thread dumps even from remote environments, and supporting Kotlin coroutines. Netflix experienced a specific issue after transitioning to virtual threads, discovering a deadlock caused by limitations in the technology, which was later resolved. IntelliJ IDEA facilitates this process by providing comprehensive thread dump analysis, including lock information, which is invaluable for diagnosing real-world problems. As Java continues to evolve with features like structured concurrency, tools and developers must adapt to leverage these capabilities effectively.

Advent of Code 2025 in Rust was a vibrant event where Rust enthusiasts, known as Rustaceans, tackled algorithmic puzzles while celebrating the coding season. The event featured 12 puzzles and daily highlights of RustRover features, culminating in a competition where participants could join leaderboards for top scores and random prizes. Vitaly Bragilevsky's blog on using AI responsibly in the challenge set the tone for the event, which honored both top performers and randomly selected winners. Duro, JohnX4321, MaRcR11, Giacomo Stevanato, and Agnibha Chakraborty were the standout performers among the 71 competitors, while bragrseg, ViincentLim, N. Adhikary, Gunter Schmidt, and Saurav Kumar were randomly awarded. Participants were encouraged to continue honing their Rust skills using resources like the RustRover Advent Calendar and the Rust AoC Template on GitHub. The event was a testament to the community spirit and learning opportunities fostered by Eric Wastl and the Advent of Code team.

Docker has revolutionized software development by enabling applications and their dependencies to be packaged into portable containers, but scaling this process requires a robust CI/CD system. TeamCity offers a comprehensive solution with first-class Docker support, which simplifies the creation and maintenance of Docker pipelines compared to Jenkins. While Jenkins relies heavily on plugins and custom scripts, TeamCity integrates Docker functionalities directly, offering features like dedicated build runners, native registry support, and Kotlin DSL for pipeline configuration. This integration reduces the complexity and maintenance burden often associated with Jenkins, providing a more reliable and scalable system. TeamCity's native Docker support includes secure registry authentication, image cleanup, and caching features that enhance both the security and efficiency of Docker pipelines. As a result, developers can focus more on delivering software rather than managing the intricacies of CI/CD pipelines, making TeamCity an appealing choice for those looking to modernize their container workflows.

In "News How Mobile Development Teams Use Kotlin in 2025," José Luis González, a JetBrains-certified Kotlin Trainer, provides insights into effective Kotlin practices for mobile development teams. He emphasizes avoiding swallowing `CancellationException` in catch blocks to preserve cooperative cancellation, using Firebase Crashlytics and Sentry for monitoring app performance and stability, and employing profiling techniques like Android Studio's CPU and memory profilers, JankStats, and LeakCanary to identify performance bottlenecks. González also advocates starting with a small project to explore Kotlin Multiplatform, such as a shared data or utility layer, to demonstrate its efficacy in cross-platform development. His insights are grounded in practical application and are geared towards helping teams improve their Kotlin skills and application performance.

Qodana 2025.3 introduces significant enhancements aimed at improving code quality, security, and compliance for development teams, including the new Global Project Configuration feature, which centralizes linter configurations for entire organizations, allowing for scalable and standardized policy management. This update simplifies the process of maintaining code quality across various projects by enabling simultaneous application of specific configurations and supports logical organization and reuse of configurations. Enhancements also include an improved license auditing tool for .NET projects that now supports a broader range of dependencies and better monorepository support for Java/Kotlin projects, allowing Qodana to recursively collect projects from subdirectories if no root-level project file is detected. These updates streamline large-scale code analysis and compliance management, making it easier for teams to enforce best practices and maintain standards across multiple languages and repositories.

IntelliJ IDEA 2025.3.1 has been released, offering a series of improvements and bug fixes that enhance the overall functionality and user experience of the IDE. Users can update to this version through various methods, including directly from the IDE, Toolbox App, snaps for Ubuntu users, or by downloading from the website. Key updates include the reintroduction of the Resume Build From button in the Run tool window for Maven projects, an option to disable the warning dialog on force-pushing in the Version Control settings, and improved behavior of query result tabs aligning with active editor tabs. Additionally, several issues related to running or debugging in WSL using Gradle and mouse text selection in the terminal have been resolved. The IDE now correctly loads suggested plugins and fixes a display issue with the Fish shell in Docker or SSH sessions. Users are encouraged to review the release notes for a detailed list of fixes and to report any new issues via the issue tracker.

JetBrains has introduced the Next Edit Suggestions (NES) feature across all its IDEs for AI Pro, AI Ultimate, and AI Enterprise subscribers, enhancing the code editing experience by proposing edits beyond immediate code completion. Unlike traditional AI code completion, NES can suggest modifications to existing code, appearing in a non-intrusive way in the editor, and is designed to work efficiently without consuming the user's AI quota. The feature relies on a custom AI model that leverages cloud GPU infrastructure to maintain low latency, integrating with JetBrains' IDE actions to provide reliable code insights. While NES complements rather than replaces existing code completion tools, it is currently unavailable to AI Free license holders, though efforts are underway to expand its availability. To streamline user experience, JetBrains is also simplifying the settings for AI code completion and NES, allowing users to customize their preferences from a single screen. The development team is actively working on further improvements to NES, such as smarter suggestions and additional IDE actions, and expresses gratitude to users who participated in the feature's beta testing phase.

Following feedback on the 2025.3 release, JetBrains has decided to revert recent changes made to the query workflow in DataGrip and the Database Tools plugin for its IDEs, after recognizing that the redesign caused significant issues, particularly with global data sources. The rollback will be included in the 2025.3.1 update, reinstating query consoles as the default workflow, functioning as they did prior to the 2025.3 update. Query files created during the redesign will remain accessible, with options to delete or convert them into query consoles. The company acknowledges the disruption caused and is committed to a zero-regression standard, promising a more intuitive and flexible query file workflow in future updates. The DataGrip team emphasizes its dedication to minimizing the impact on users and invites feedback through support channels, while maintaining a focus on enhancing user experience in future developments.

JetBrains has released the 2025.3.1 updates for its .NET tools ReSharper and Rider, incorporating several important fixes and enhancements. Among the notable features is the introduction of Next Edit Suggestions (NES) in Rider, powered by JetBrains AI, which provides intelligent recommendations for edits across entire files, enhancing coding efficiency. The update also includes refined data-sharing capabilities aimed at improving AI feature quality while respecting user data preferences. Additionally, several technical issues and vulnerabilities have been addressed, such as the restoration of normal operation for the Suggested Plugins dialog and the resolution of security vulnerabilities CVE-2025-64456 and CVE-2025-64457. Users can enable these new features and provide feedback directly within the IDE, with the overall update aiming to enhance the reliability and functionality of JetBrains tools.

JetBrains Academy's annual course roundup for 2025 highlights both popular and new offerings aimed at helping learners enhance their programming skills through in-IDE courses that emphasize practical, hands-on coding experiences. The platform offers free courses such as "100 Days of Code," "Introduction to Python," and "100 Exercises to Learn Rust," which are designed to cater to different skill levels, from beginners to more advanced programmers. In 2025, JetBrains introduced new courses and partnerships, including Skill Paths with AWS for practical experience in deploying apps and AI-Assisted Programming with Nebius to navigate the integration of AI tools in coding. JetBrains Academy also expanded its reach by launching courses on Coursera, offering a seamless learning experience by integrating with IDEs like PyCharm and IntelliJ IDEA. Additionally, a Java Foundations Professional Certificate was launched on LinkedIn Learning to bolster learners' credentials in the job market. These developments underscore JetBrains Academy's commitment to providing diverse, real-world learning opportunities in programming and technology.

Successfully adopting Kotlin in a Java-dominated environment involves understanding the interplay of people, timing, risk, and trust rather than simply replacing Java with Kotlin. The guide, encapsulated in a downloadable PDF, outlines a five-stage process beginning with introducing Kotlin through testing suites to ensure it feels beneficial before progressing to production. It emphasizes starting new services in Kotlin and integrating Kotlin modules into existing systems while avoiding common pitfalls. The guide also highlights the importance of engaging colleagues by sharing focused examples and fostering an in-house community, and it provides strategies to persuade decision-makers by illustrating Kotlin’s business value, such as reduced code maintenance and fewer defects. Finally, for scaling adoption, the guide advises a strategic approach to migration, treating systems based on their lifecycle, and leveraging tools like IDE conversion and AI-assisted refactoring to manage transitions without disrupting operations. This comprehensive guide is designed for Java developers, tech leads, and decision-makers who seek a methodical, low-risk approach to integrating Kotlin into their workflows.

Bring Your Own Key (BYOK) is now available in JetBrains IDEs, allowing users to integrate their own API keys from providers like Anthropic and OpenAI without needing a JetBrains AI subscription. This feature supports a variety of models, ensures cost transparency, and maintains privacy by storing API keys locally. Users can easily set up BYOK by installing the JetBrains AI Assistant plugin and selecting their desired provider and models. While not all AI features are compatible with third-party models, using BYOK in conjunction with JetBrains AI can enhance functionality and provide comprehensive support. JetBrains plans to expand BYOK by adding new providers such as Google Gemini, Azure, and Amazon Bedrock, and encourages user feedback for further improvements.

AI functions as an amplifier of existing habits within an organization, magnifying both strengths and weaknesses rather than transforming them. Teams that maintain structured practices such as clean code, test-driven development, and thorough documentation benefit from AI's ability to handle repetitive tasks, thereby enhancing productivity and code quality. Conversely, teams lacking discipline and clear processes may find AI exacerbates their inefficiencies. Studies, such as those by MIT, the U.S. Census Bureau, and McKinsey, indicate that organizations with disciplined management practices see greater long-term benefits from AI adoption. AI operates like an intern, learning from surrounding practices, and when integrated into well-established systems, it can scale operations efficiently. However, without a clear framework and disciplined delegation, AI can introduce errors and confusion. Ultimately, AI reflects and amplifies the existing culture and processes, making it critical for organizations to cultivate good habits to maximize AI's potential benefits.

KotlinConf 2025 showcased the growing adoption of Kotlin by leading global brands such as Meta, AWS, Duolingo, Uber, and others, highlighting real-world engineering solutions and best practices. At the event, companies shared insights into using Kotlin to tackle complex engineering challenges, including navigation systems, performance improvements, cross-platform architectures, and large-scale code migrations. AWS discussed scaling their SDK for Kotlin, while Duolingo highlighted Kotlin Multiplatform's role in accelerating their feature delivery. Google Workspace's session focused on deploying Kotlin Multiplatform, and Meta introduced Kotlin support in their Buck2 build system. Additionally, the McDonald's app team shared their navigation solutions using Kotlin Multiplatform, and Uber explained their AI-driven migration from Java to Kotlin. X (formerly Twitter) described their experience with a cross-platform KMP project. The conference served as a platform for engineers to share practical lessons and connect with the global Kotlin community, fostering innovation and collaboration in the Kotlin ecosystem.

MPS 2025.3 introduces significant updates, including a complete overhaul of the JavaDoc language, improvements to generator plans, and updates to the reflective editor. The JavaDoc language now utilizes the jetbrains.mps.lang.text language, enhancing consistency with other MPS languages and allowing for text styling such as bold and italics, which are rendered as HTML tags in Java source files. The update also introduces a "Paste as JavaDoc" action, improving the integration of JavaDoc code into BaseLanguage. Generator plans now feature PlanContribution, replacing the previous fork functionality, and support conditional activation, allowing for more nuanced model transformations. TextIcon has been updated to offer visually distinct options for light and dark themes, while the reflective editor has been redesigned for a more unified experience with the read-only default editor.

JetBrains is committed to maintaining an open and neutral stance in the development and support of protocols for AI agents in integrated development environments (IDEs). They have developed the Agent Client Protocol (ACP) in collaboration with Zed, which is designed to allow IDEs and editors to communicate with coding agents, similar to the Language Server Protocol (LSP) but specifically for AI agents. Meanwhile, GitHub has launched AgentHQ, a centralized system for managing AI agents within the GitHub ecosystem and VS Code, handling tasks such as permissions and integration. JetBrains emphasizes their commitment to openness and flexibility, supporting multiple protocols to ensure that agents are not confined to a single IDE or cloud platform. They encourage agent builders to use whatever protocol best serves their users, whether it is ACP, AgentHQ, or others, with the goal of promoting portability and enhancing user experience across different platforms.

DataGrip, the database IDE, celebrates its 10th anniversary since its initial release on December 16, 2016, evolving from its original codename, 0xdbe, into a widely used tool. The milestone is marked by a reflection on its journey and a gift to users in the form of a list of ten lesser-known features within the software. These features include advanced text completion, recent location tracking, customizable backgrounds, schema dumps via the SQL generator, and the ability to copy and share data sources as XML snippets. Additional functionalities such as local history recovery, SQL region folding, presenting database nodes as tables, an integrated calculator, and database object attachment in AI chats enhance user experience by offering more efficient and personalized workflows. The DataGrip team expresses gratitude to its users for their support and invites them to share their experiences with these features.

The article compares C++ and Rust, two high-performance systems programming languages, highlighting how each addresses modern development challenges. C++ is a mature language offering immense control and a vast ecosystem, making it ideal for existing projects and performance-critical systems. However, it requires significant programmer discipline to manage memory and avoid runtime errors. Rust, emerging as a strong contender since its 2010 debut, prioritizes memory safety and concurrency through compile-time checks, reducing runtime bugs and improving code reliability. While C++ often leads in microbenchmarks, Rust holds its own in real-world scenarios, demonstrating comparable performance with added safety features. Both languages are seen as complementary, with Rust offering modern tools and ergonomics that appeal to a new generation of developers. The choice between them depends on project requirements, safety priorities, and team expertise, as both continue to evolve and gain traction across various industries.

Kotlin 2.3.0 has been released, introducing a range of enhancements and new features across various platforms, including improvements in language stability, tooling, and performance. This release offers updates such as a new unused return value checker, explicit backing fields, and changes to context-sensitive resolution for the language. On the JVM, there's support for Java 25, and for Kotlin/Native, enhancements include improved Swift interop and faster build times. Kotlin/Wasm introduces better handling of fully qualified names and a new compact storage for Latin-1 characters, while Kotlin/JS sees experimental features like suspend function export and unified companion object access. Additionally, Gradle compatibility is updated for version 9.0, and the standard library now includes stable time tracking and improved UUID functionalities. The release also acknowledges numerous contributors and issue reporters, emphasizing community involvement in the development process. For installation, the Kotlin plugin is available in IntelliJ IDEA and Android Studio, with further information and updates accessible through official documentation and community support channels.

Flaky tests, which intermittently fail due to factors like timing issues, dependencies, or resource contention, can undermine developer confidence and CI/CD pipeline reliability. This article highlights how TeamCity addresses these challenges by automatically detecting and marking flaky tests, thus reducing false positives and enhancing clarity on test failures through features like built-in history, investigations, and mutes. Unlike traditional systems like Jenkins that rely heavily on plugins and custom scripts to manage flaky tests, TeamCity offers built-in test intelligence that provides direct visibility into test history and allows for smart retry configurations, which target only specific test cases instead of entire builds. This approach helps separate genuine defects from transient glitches, and the mute-and-monitor pattern keeps pipelines stable by silencing failures in the main build while tracking them in the background. TeamCity's tools for managing flaky tests aim to improve productivity and trust in the CI/CD process, making it feasible for teams to maintain a green pipeline without losing sight of problematic tests.

TeamCity 2025.11.1, the first update for the major 2025.11 version, has been released, addressing several key issues such as problems with pull request build parameters in composite builds, incorrect branch building after empty merge commits, inaccessible build status colors for users with color vision impairments, and the unavailability of the latest Visual Studio build tools in new .NET pipeline runners. This bug-fix update also enhances performance and security, making it advisable for users to install it promptly. The update maintains compatibility with all 2025.11.x releases, allowing for easy upgrades or downgrades without data backup and restoration. Users can update through the automatic feature in TeamCity, download from the JetBrains website, or pull the updated Docker image. For any queries or issues, support is available through the TeamCity Forum or Issue Tracker.

In the third installment of a series on building AI agents in Kotlin, the article addresses the growing complexity of debugging as AI agents become more capable, highlighting the need for enhanced observability to improve, debug, and estimate costs effectively. The article discusses integrating tracing with Langfuse, an open-source observability tool, to provide a detailed view of the agent's actions, including cost per action. This integration reveals the agent's decision-making trajectory, helping to identify inefficiencies and errors that are difficult to detect through traditional logging methods. By implementing Langfuse, the development team can track important metrics like token usage and costs, providing insights into the agent's performance. This visibility aids in identifying specific issues, such as a tool's failure to handle line count discrepancies, and facilitates more informed decisions about task delegation in future developments. The article emphasizes the importance of observability not only for debugging but also for gaining a deeper understanding of the agent's behavior, ultimately leading to more efficient and effective AI agents.

JetBrains supports and highlights various open-source projects in the developer community, focusing on tools that enhance system reliability across different programming languages such as Rust, Go, and JavaScript. Notable projects include frp, a Fast Reverse Proxy that simplifies network setup for developers; Sniffnet, a Rust-based tool for real-time network traffic visualization; Vitest, a testing framework for JavaScript with strong JetBrains collaboration; and bottom, a terminal-based system monitor initially developed as a personal project. These projects benefit from JetBrains IDEs, which provide features like code completion, debugging, and seamless workflow integration, thereby enhancing the developer experience. JetBrains remains committed to fostering open-source development by offering free licenses and contributing to community-driven initiatives.

Qodana has introduced first-class Kubernetes support to enhance scalability and control for engineering teams as they grow and face increased demands on their tooling. This new integration allows for fully automated deployments and lifecycle management, making it easier to manage code-quality checks in more complex, cloud-native development environments. By deploying Qodana using Kubernetes, organizations can benefit from predictable, repeatable deployments, automated updates, and better integration with existing platform engineering workflows. The introduction of a Helm Chart for Qodana facilitates the deployment, management, and scaling of Qodana Self-Hosted, offering stability, faster onboarding, secure operations, and improved integration with GitOps workflows. Looking ahead, Qodana plans to develop a Kubernetes Operator to further simplify deployment and lifecycle management, inviting users interested in scaling code quality within Kubernetes environments to engage with their team.

Benchmarking in Kotlin is enhanced by using Kotlin notebooks, which provide a more interactive and visual approach to interpreting performance data generated by the kotlinx-benchmark library. While raw text results from benchmarking can be limiting, Kotlin notebooks allow developers to load results as structured data, explore them using the DataFrame API, and visualize them with charts. This method offers a clear and immediate overview of performance variations and stability across different implementations or hardware setups. Additionally, Kotlin notebooks facilitate the comparison of benchmark results from different environments or code commits by enabling the analysis and plotting of data, which can be read from JSON files generated by kotlinx-benchmark and converted into typed DataFrames. These notebooks support statistically rigorous comparisons by accounting for confidence intervals and offer features for sharing and publishing results, such as creating GitHub gists or using JetBrains Datalore for online viewing. This workflow not only improves understanding but also aids in the reproducible tracking of performance metrics within a team.

The latest updates for ReSharper and Rider 2025.3.0.4 include significant bug fixes and feature enhancements, with a focus on improving user experience and integrating AI capabilities. Key updates in Rider involve the introduction of a multi-agent experience in the AI Chat window with Claude Agent, providing seamless switching between AI assistants for enhanced workflow flexibility. Rider also introduces transparent AI quota tracking within the IDE and plans to support the "Bring Your Own Key" feature, allowing users to connect to AI models using their own API keys. For game developers, cloud-powered multi-line code completion is now available for Unity, Unreal Engine, and Godot projects. The update also addresses various technical issues, such as excessive memory usage with .NET 6 solutions and restoring full WSL support. ReSharper's update focuses on allowing SQL/NoSQL support to be excluded from installations and fixing the Unit Test Output panel's scrolling issues. These updates aim to streamline development processes and offer more control over AI usage within JetBrains IDEs.

JetBrains has released the final update of 2025 for the JetBrains Academy plugin, version 2025.11, which includes significant changes such as the introduction of a standalone Hyperskill plugin. This new plugin aims to enhance the learning experience for Hyperskill users by providing streamlined updates, simpler navigation, and a more cohesive workflow. While the JetBrains Academy plugin will continue to support JetBrains Academy and Coursera courses, all Hyperskill content will now be accessed through the new Hyperskill Academy plugin. Existing Hyperskill projects and progress will remain intact, and users are encouraged to switch to the new plugin for a more focused learning environment. Additionally, the update expands the achievement-sharing feature to IDE-based courses, allowing learners to share their progress on platforms like X and LinkedIn, thus boosting motivation and potentially inspiring others. The update promises to offer a smoother learning experience, with detailed improvements listed in their issue tracker, and JetBrains invites feedback from users to further enhance their offerings.

Datalore 2025.5 introduces several new features and enhancements, including Git integration for workspace backups, enabling users to export workspaces to platforms like GitHub and GitLab for secure storage and change tracking. The update also allows the sharing of interactive reports with preselected values, streamlining the process for recipients by eliminating the need to manually adjust controls. Additionally, reports now support a mobile layout, enhancing usability across devices. The AI Assistant in Datalore Cloud has been upgraded with new language models, and for On-Premises users, administrators can select the most suitable default model for their organization. These updates are available for Datalore Cloud users now, while On-Premises users can access them through an instance update.

The TeamCity Operator for Kubernetes streamlines the deployment and management of TeamCity instances by automating the life cycle processes typically managed manually, such as server deployment, updates, and multi-node coordination. Unlike Helm charts, which are limited in handling stateful applications, the TeamCity Operator introduces a Kubernetes custom resource that facilitates seamless integration and operation of TeamCity within Kubernetes environments. This tool allows for zero-downtime upgrades and offers a code-driven approach to configuration by integrating with Terraform and the Kotlin DSL, enhancing the consistency and reproducibility of CI/CD setups. Initially developed for internal purposes, the TeamCity Operator has been made open-source due to growing demand from users with large Kubernetes installations, and it is now available with examples and documentation in its GitHub repository, with further resources and events planned for the future.

Datalore 2025.6 introduces several enhancements aimed at improving user productivity and organization, with features such as the Issue Center for tracking and resolving report errors and a Usages tab for database connections to manage dependencies more effectively. The release allows for streamlined role changes in Datalore On-Premises, optimizing license usage by enabling direct role adjustments from user to viewer without account deletion. Users can now access all reports, including shared and public ones, through a new All Reports tab, while recent activity is tracked in an updated Recents tab. Interactive report recalculation settings ensure viewers access the latest data, with options for automatic updates, and individual reports from shared workspaces can now be shared without exposing the entire workspace. Additionally, automatic environment installation for pip-based environments on machine startup enhances operational efficiency. These updates collectively aim to provide a smoother and more efficient experience for Datalore users.

IntelliJ IDEA has unveiled a major update to its Search Everywhere feature, introducing a new API designed to enhance remote development capabilities by decoupling the search logic from its UI presentation. This architectural overhaul addresses challenges in remote environments, where search operations are executed on robust backend systems while results are displayed on lightweight frontend clients. By separating data from presentation, the update ensures reliable serialization and transmission of search results across networks. The new API features components like SeItemsProvider and SeTab, which facilitate this separation and support new plugin development. Existing plugins can continue operating in monolithic environments without immediate changes, but for remote environments, plugin developers are encouraged to adopt the new API or ensure legacy implementations are compatible with the updated architecture using provided adapters. The gradual rollout plan anticipates full adoption by 2026, allowing developers time to transition and provide feedback during the experimental phase. This change is pivotal for sustaining IntelliJ's effectiveness in modern remote development scenarios.

In 2025, backend development teams are leveraging Kotlin to address common anti-patterns and optimize their codebase, as outlined by José Luis González, a JetBrains-certified Kotlin Trainer. Teams often struggle with legacy Java habits, such as overusing inheritance, which can be resolved by adopting Kotlin's data-oriented and expression-based designs. Other prevalent issues include the misuse of ambient singletons and typealias, which can be mitigated by using context parameters and value classes, respectively. Coroutines are frequently misunderstood as mere threads, leading to inefficient code, but can be managed effectively with proper scoping and structured concurrency. For testing asynchronous Kotlin code in CI/CD environments, injecting dispatchers and employing deterministic testing patterns are recommended. When diagnosing unexpected memory usage in Kotlin microservices, González advises examining JVM behavior, limiting thread and buffer usage, and profiling to identify the source of memory consumption. His insights reflect a broader trend toward idiomatic Kotlin practices that enhance performance and maintainability.

PhpStorm 2025.3 introduces built-in support for Laravel, eliminating the need for separate plugins and configurations, a feature long requested by PHP developers. This integration allows developers to start working on Laravel projects immediately upon opening them in the IDE, enhancing the overall development experience. The update is the result of collaboration among key figures from the PhpStorm and Laravel communities, including PhpStorm Team Lead Roman Pronskiy, Laravel creator Taylor Otwell, and others. While users of IntelliJ IDEA can still use the Laravel Idea plugin by installing it from the marketplace, PhpStorm's integrated support is available to all users, including those on free trials or holding special licenses. The Laravel Idea plugin will continue to be maintained to ensure a top-tier development experience, and it now comes pre-installed and enabled in PhpStorm, making manual management unnecessary.

JetBrains has partnered with Cloud9 to launch "Sky’s the Limit," a global hackathon aimed at developers, esports fans, analysts, and creators to advance competitive gaming through innovative solutions. Participants can choose from four main categories, including building an assistant coach with analytics, generating automated scouting reports, developing an AI drafting assistant, and designing a fan-engaging event minigame. The hackathon offers significant prizes, including cash, gift cards, software subscriptions, and an all-expenses-paid trip to the Game Developers Conference (GDC). Submissions will be evaluated by judges from both JetBrains and Cloud9, with registration and submissions opening in December 2025 and winners announced in March 2026. This event encourages participants to leverage JetBrains IDEs and AI tools to drive technical creativity and innovation in esports, impacting team performance and fan interaction.

JetBrains has introduced the Islands theme as the default interface for its IDEs starting with version 2025.3, aiming to provide a visually softer and more cohesive environment that enhances focus and comfort for developers. This update features a clean, uncluttered layout with rounded corners and balanced spacing, making the user interface easier on the eyes, along with more distinct tool window borders that facilitate workspace customization. The theme also improves tab recognition for quicker navigation and organizes the interface to clearly separate working areas, which helps maintain focus. This design reflects feedback from daily users and aligns with contemporary design trends in macOS and Windows 11, ultimately supporting developers in staying productive and focused on coding tasks.

WebStorm 2025.3 introduces a range of enhancements and new features, focusing on improving TypeScript type evaluation, monorepo support, and remote debugging capabilities. This release includes a service-powered type engine for more accurate TypeScript evaluations, better module resolution, and support for pnpm and Nx workspaces. The AI Assistant has been upgraded with Claude Agent and Junie integration, offering enhanced chat capabilities. Developers can now use WebStorm's JavaScript debugger in remote environments like WSL and Docker, with additional support for launching browsers on local machines. The update also aligns CSS syntax with the latest specifications, supports Vitest 4, and includes numerous quality-of-life improvements for frameworks such as Angular, Vue, Astro, and Prettier. A new unified JavaScript Runtime settings page consolidates configuration for Node.js, Bun, and Deno, and the introduction of the Islands theme offers a refreshed visual experience.

IntelliJ IDEA 2025.3 introduces an array of improvements and bug fixes aimed at enhancing the developer experience across various facets of the IDE. The release unifies the Ultimate and Community Editions into a single, smaller distribution, simplifying development and improving overall quality. Key updates include better handling of indexing, more detailed file navigation in complex codebases, and accessibility enhancements such as improved magnifier functionality on Windows. The release also strengthens support for Spring Framework 7, Spring Boot 4, and Java 25, with ongoing efforts to accommodate future Java features. Noteworthy updates in the Kotlin and Scala plugins enhance code search and performance, while GitHub and GitLab integrations see improved user experience with manual review marking and multi-line comment support. Additionally, the terminal and build tools receive performance upgrades, and web development sees improved module resolution and monorepo support for JavaScript and TypeScript. Overall, the release prioritizes UI responsiveness and performance, addressing issues like TypeScript highlighting and navigation freezes.

IntelliJ IDEA has transitioned into a unified product, combining the Community Edition and Ultimate Edition into a single offering starting with the 2025.3 release. This change simplifies the user experience by eliminating the need to choose between editions, allowing users access to both core and extended features within one platform. The core features of the former Community Edition remain free for both non-commercial and commercial use, while additional free features have been introduced, such as syntax highlighting for Spring and database connection tools. The Ultimate subscription, which includes extended tooling, offers a free 30-day trial. This unification aims to enhance product quality by concentrating development resources, and the open-source codebase remains available on GitHub. Existing users of both editions will experience a seamless transition, with educational licenses continuing to provide free access to the Ultimate features for educators and students. This strategic move underscores JetBrains' commitment to innovation and the open-source community, promising a more powerful and user-friendly experience for developers.

The Release Candidate for MPS 2025.3 has been made available for download as the final step before the official release. This version follows the updates from the Early Access Program (EAP) builds, with a full list of fixed issues accessible online. Users can stay informed about this and future updates by subscribing to the MPS Blog, ensuring they are kept in the loop about developments from the JetBrains MPS team.

Jenkins, a popular CI/CD tool, is lauded for its flexibility and extensive plugin ecosystem, which allows for automation of builds, tests, and deployments. However, this flexibility can lead to configuration drift, particularly when changes are made through the Jenkins UI (known as "click-ops") that are not reflected in the code, such as Jenkinsfiles or Job DSL scripts. This drift causes inconsistencies across environments, complicating build reproducibility, compliance, and disaster recovery. To manage configuration drift, it's crucial to establish a baseline of the Jenkins environment using tools like Jenkins Configuration as Code (JCasC), monitor changes with plugins like Job Configuration History, and transition configurations to code to maintain a single source of truth. Additionally, enforcing access controls and implementing continuous detection and remediation strategies, such as the use of the Matrix Authorization Strategy and Configuration Slicing plugins, are essential. These measures ensure configurations are auditable, reproducible, and aligned with DevOps best practices. For those looking to eliminate configuration drift entirely, alternatives like JetBrains TeamCity offer built-in configuration versioning and a more polished developer experience.

The December 2025 edition of Java Annotated Monthly highlights significant updates in the Java ecosystem, including the announcement of JEPs for future Java releases and the introduction of Spring Framework 7 and Spring Boot 4, which offer new features like API versioning and enhancements to HTTP service clients. This issue also features content curated by Siva Katamreddy, a Developer Advocate at JetBrains, who shares insights into building cloud-native applications. Noteworthy changes in Spring Boot 4 include modularization of the spring-boot-autoconfigure JAR to reduce the runtime footprint, and Dan Vega's video series provides an overview of these updates. IntelliJ IDEA 2025.3 now supports these Spring advancements, enhancing its integration with tools like Spring Data JDBC. Additionally, the release of Spring AI 1.1 GA introduces a simplified annotation-based programming model for building GenAI-powered applications. The publication covers a variety of topics including Java tutorials, Kotlin updates, AI developments, and industry trends, along with announcing upcoming conferences and events for developers.

IntelliJ IDEA 2025.3 marks the official deprecation of K1 mode in favor of the advanced K2 mode, which has been widely adopted by users due to its enhanced performance, stability, and feature set for Kotlin development. K2 mode addresses the limitations of its predecessor by offering a rebuilt analysis engine that improves scalability and speed, facilitated by the inclusion of the Kotlin Analysis API. The transition to K2 mode has yielded substantial performance improvements, such as a 39% increase in code analysis speed and a 34% boost in the "Find Usages" feature, while also enhancing stability with fewer support requests and exceptions. While K2 mode has nearly achieved feature parity with K1 mode, ongoing efforts are being made to address rare feature usage and optimize performance further. User feedback has played a crucial role in shaping K2 mode, and IntelliJ IDEA plans to continue building on these architectural advancements to enhance Kotlin tooling in future releases.

The latest release of the IntelliJ Scala Plugin, version 2025.3, introduces enhanced support for Scala 3.8, incorporating a new "into" modifier, and updates the standard library to be compiled with Scala 3 while also requiring a minimum JDK version of 17. This release focuses on various improvements like better navigation through macros, export aliases, and extension methods, with the anticipated Scala 3.9 LTS release focusing on stabilization. The plugin now supports Structural Search and Replace (SSR) in IntelliJ IDEA, which allows developers to search for and replace code patterns based on structure, a significant advantage for managing large codebases. Initial support for Scala 3 in build files has been added, alongside improvements in Mill project navigation and bug fixes such as correcting the Refactor | Rename action. Performance enhancements have been made, including faster editor actions and optimization tips available in the settings. Contributions from the Scala community, highlighted by a recent hackathon, have led to improvements like fixes for unnecessary parentheses and new refactoring options, demonstrating an ongoing commitment to refining the plugin.

JetBrains is organizing a series of Ask Me Anything (AMA) sessions on Reddit from December 9 to 12, where their product teams will engage directly with developers using their tools. These sessions, designed for open and honest dialogues, aim to address what works well, what doesn't, and gather user priorities to help shape the future of JetBrains products. Each AMA session is scheduled for specific products, including WebStorm, GoLand, IntelliJ IDEA, PyCharm, DataGrip, .NET Tools, Kotlin, CLion, RubyMine, and JetBrains AI, with dedicated time slots throughout the week. Participants are encouraged to submit their questions during the AMA windows on Reddit, where the JetBrains teams will provide live responses.

JetBrains Rider, a popular integrated development environment (IDE), offers a free non-commercial use license that has inspired developers worldwide to embark on innovative projects driven by curiosity and passion rather than financial gain. This initiative has empowered individuals like Anton Makarevich, who developed a digital board game with AI integration, and Fabio Scagliola, who created a platform for writers to share drafts privately, to explore their interests without commercial constraints. The stories of these developers highlight the diverse applications of Rider, from hobby projects to educational tools, as seen in Chris Lopes' development of an AI-assisted learning tool at Gonzaga University. The free license has also facilitated learning and experimentation for hobbyists like Darren Hind, who transitioned from practical applications to more complex development using Rider's robust features. Meanwhile, Gregori Bruno Felicio utilized Rider to develop G#, a new programming language, underscoring the platform's role in fostering creativity and innovation within the coding community. These narratives collectively demonstrate the potential unlocked when professional-grade software is accessible to all, encouraging both individual growth and collaborative exploration.

dotInsights by JetBrains provides the latest updates and insights into the .NET and software development community, featuring highlights such as .NET 10 updates, new C# 14 features, and tools for improving coding practices. The newsletter advises caution with using explicit garbage collection in .NET due to potential performance drawbacks. It also offers tutorials on localization in .NET and shares news about JetBrains' latest releases, such as Rider 2025.3, which supports .NET 10 and C# 14, and improvements in ReSharper and ReSharper C++ for compatibility and performance. Additionally, the newsletter encourages community engagement through events like the F# Advent Calendar and offers a platform for feedback and discussion.

JetBrains has integrated xAI's Grok family of large language models (LLMs) into its integrated development environments (IDEs) to enhance its AI chat capabilities, offering models such as Grok 4, Grok 4.1 Fast, Grok 4.1 Fast (Non-Reasoning), and Grok Code Fast 1. This integration provides users with the flexibility to select the model that best suits their workflow for tasks like code refactoring, error fixing, and test generation. Users can access these models by ensuring they have an active JetBrains AI subscription or by starting a free trial directly from their IDE, after which they can interact with the AI chat to utilize the models' capabilities.

Long build times can significantly disrupt developer productivity and increase release cycle times, making it essential for teams to optimize their CI/CD pipelines. The article outlines a strategic three-phase approach to enhancing pipeline performance using TeamCity, focusing on identifying bottlenecks, applying targeted optimizations, and ensuring continuous improvement. Initially, teams should assess pipeline performance by analyzing metrics like build duration and resource utilization to identify areas for improvement. Optimizing performance involves implementing changes such as build caching, parallelization, and modularization to enhance efficiency and reduce build times. Continuous improvement is achieved by utilizing elastic infrastructure, designing pipelines to build only changed components, and fostering a performance-oriented culture. TeamCity's features, such as its Statistics dashboard, Performance Monitor, and cloud profile management, support these efforts by providing visibility, flexibility, and scalability, ultimately helping teams maintain momentum and improve product output and quality.

DataGrip 2025.3, the latest and final major update of the year, introduces several enhancements, including a shift from query consoles to query files that can be automatically migrated and integrated into IDE projects. The update enhances connectivity by enabling connections to AWS, Google Cloud, and Azure, and introduces introspection levels for Amazon Redshift that adjust metadata loading based on database size. The database explorer has been redesigned to allow rearrangement of folders, and AI-based features now enhance the Explain Plan actions. The code editor tracks query history, supports Snowflake database classes, and introduces new data types and indexes for Microsoft SQL Server. The update also includes UI and UX improvements, such as a redesigned main menu and the default use of the Islands interface theme.

A new IntelliJ IDEA livestream scheduled for December 11, 2025, will feature a discussion on the updates in Spring Boot 4, emphasizing enhancements in developer productivity and offering insights into the migration process for modern Java and Kotlin development. The session will include core maintainers Stéphane Nicoll, Brian Clozel, and Mark Paluch, as well as host Evgeny Borisov, who will explore the most impactful changes, motivations behind these updates, and key considerations for upgrading applications. The event will also provide a platform for discussing life, technology, and the community, with opportunities for participants to ask questions, which will be addressed during the session or in a follow-up blog post if time runs out.

Katie Fraser's research highlights the inefficiencies of large language model (LLM)-powered agents in managing context, which can lead to excessive memory usage and costs without improving performance. Traditional methods like LLM summarization and observation masking are employed to manage context growth, with observation masking emerging as a simpler yet more cost-effective strategy. This approach replaces older observations with placeholders, thereby reducing memory usage without compromising the agent's problem-solving capabilities. Fraser's study, part of Tobias Lindenbauer's master's thesis at TUM, also introduces a novel hybrid approach combining both strategies for enhanced efficiency, reducing costs and maintaining performance. The study emphasizes the importance of efficient context management in AI agents and suggests that a combination of strategies can achieve significant cost savings and improved performance.