September 2026 Summaries

Emiliano Bonilla, CEO and co-founder of Synnax, describes the company as a real-time hardware control and data platform designed for demanding applications such as rocket engine testing, where legacy workflows often rely on spreadsheets and poorly organized multi-terabyte data files. Drawing on his experience building aerospace ground software at Firefly Aerospace, Bonilla founded Synnax to help teams collect, organize, review, and act on sensor data more quickly, reducing risks in environments where millisecond-level failures can damage costly hardware. Synnax developed Arc, a simplified real-time programming language, after finding Excel unsuitable for complex control logic and Python insufficiently fast and safe for engine control. The team uses JetBrains tools including GoLand, CLion, and PyCharm, alongside Claude Code, particularly valuing integrated debugging and code-review capabilities. While aerospace remains its primary market, Synnax is expanding into cryogenic control for quantum computing, oil and gas, and manufacturing, and is developing automated anomaly detection to improve data review. The interview also outlines JetBrains Startup Program eligibility, application review timing, and the types of IDE, AI, team, and learning products available to participants.

Kotlin 2.5.0-Beta1 introduces experimental companion blocks and companion extensions, intended to expand on companion objects by supporting class-level constants, utilities, factories, and externally declared members with compilation behavior closer to static members on other platforms. Companion blocks can compile to JVM static members, while companion extensions can add class-level functionality to Kotlin or Java classes and interfaces regardless of whether their source is controlled or they already have a companion object. These features also improve Kotlin Multiplatform interoperability by allowing expected companion block members to be actualized through Java classes with static members. Developers must enable them with compiler flags, and companion extensions currently produce pre-release binaries that cannot generally be used as library dependencies until stabilization. Companion objects remain fully supported and are still necessary when the companion must implement an interface, while migration to companion blocks is often as simple as removing the object keyword, provided dependent projects are recompiled and supporting tooling is available.

Kotlin’s 2026 state report marks the language’s fifteenth anniversary by examining its maturity, global adoption, and prospects across mobile, backend, multiplatform, and AI-related development. Although Kotlin remains strongly associated with Android, more than half of its developers now work on backend projects, reflecting its expansion into a broader range of applications. The report combines JetBrains survey findings, independent industry data, and adoption evidence, highlighting that 93% of surveyed Kotlin developers use AI coding tools and 81% use or are considering AI coding agents. Most respondents also report that AI-generated Kotlin code is either correct or needs only minor revisions, while Kotlin’s static typing, null safety, and coroutines are presented as relevant strengths for AI-assisted software development.

Software quality assurance is presented as a continuous, proactive discipline that embeds reliability, security, performance, and compliance checks throughout the software development lifecycle rather than treating testing as a final release gate. As faster CI/CD delivery, complex architectures, third-party dependencies, and AI-generated code increase development risks, teams are encouraged to combine automation with human review to catch defects early and maintain oversight. Effective SQA uses layered tools suited to different stages, including requirements and design validation, static analysis, unit and integration testing, functional and UI testing, performance testing, security scanning, deployment monitoring, and post-release observability. Tool selection should consider CI/CD integration, language coverage, automation, scalability, reporting, and security, while best practices emphasize shifting checks left, automating repetitive tasks, tracking technical debt, integrating testing into every build, and treating security as a core quality responsibility.

Kotlin 2.5.0-Beta1 introduces an experimental, opt-in separate compilation mode for Kotlin Multiplatform projects that aims to align compiler behavior with IntelliJ IDEA analysis and make common code dependencies more predictable. Under the existing approach, common source sets can be compiled against platform-specific dependency artifacts, allowing calls to platform declarations that the IDE flags as unresolved, selecting different overloads than the IDE expects, and causing platform-specific type-inference failures. Separate compilation instead resolves common source sets strictly against common metadata KLIB declarations, requiring explicit expect/actual relationships for platform functionality while preventing accidental platform calls from commonMain or commonTest. This approach also creates a foundation for incremental compilation of common source sets. It can be enabled through the kotlin.kmp.separateCompilation=true Gradle property, but remains experimental, depends on libraries publishing metadata KLIBs, and has known limitations involving C interoperability, certain smaller issues, and modules with common source sets that declare only one target.

Rider 2026.2.3 adds AI-assisted performance analysis to the Monitoring tool window, allowing users to send runtime data from application sessions to an AI agent that uses the dottrace-analyze skill to identify bottlenecks, trace hot code paths, and provide performance insights in chat. The Analyze with AI action is available from the Performance tab and for older snapshots in the dotTrace tool window, but requires Windows, the AI Assistant plugin, and either dotUltimate or the All Products Pack. The release also fixes a Windows issue introduced in Rider 2026.2.2 that could prevent the AI Agent Setup widget from opening when display scaling was below 175%, and the update is available through the IDE, JetBrains Toolbox App, or the Rider website.

JetBrains has introduced Air Teams, a team-focused extension of its Air agentic development platform that is available to business customers and designed to centralize shared AI workflows, environments, tools, and instructions. The product addresses the shift from individual developer productivity to team-wide coordination through Automations, reusable cloud environments, cloud tasks, and team projects. Automations can execute recurring tasks such as pull-request reviews, bug fixes, dependency upgrades, and documentation maintenance in response to schedules or events, while preserving human oversight through reviewable pull requests and detailed run histories. Shared cloud environments package repository-specific tools, dependencies, network permissions, and secrets into version-controlled setup scripts, enabling agents and developers to reuse consistent configurations without exposing credentials. Cloud tasks run independently of a developer’s device and can be launched or monitored through JetBrains IDEs or the web, while team projects provide centralized membership, permissions, connectors, credits, and service accounts so workflows can continue even when their creators leave.

PhpStorm has announced its latest annual round of open-source sponsorships, aiming to provide financial support and raise awareness for projects that are important to the PHP ecosystem. The selected recipients are Sebastian Bergmann for PHPUnit, George Dumitrescu for the local PHP environment tool Lerd, Jerry Ma for static-php-cli, Composer as a central dependency-management tool, and Larabelles for its focus on inclusivity in the PHP community. The company said it chose projects based on their expected impact and funding needs, while acknowledging that many other deserving projects were suggested. PhpStorm also reaffirmed its support for the PHP Foundation and encouraged companies and individuals to contribute to open-source development and the broader PHP community.

A new Kotlin Multiplatform plugin integration with TeamCity Cloud is designed to guide iOS developers from their first Git push to automated testing, TestFlight publishing, and GitHub-triggered CI/CD without requiring prior CI/CD knowledge or access to a Mac. Addressing common barriers such as hosted macOS infrastructure, Apple signing, and disconnected development workflows, the progressive three-stage process lets users first build and test on hosted macOS agents, then configure signing and publish to TestFlight, and finally connect their repository for automatic builds on every push. The design was shaped through cross-functional technical collaboration and usability testing with KMP developers, emphasizing timely IDE prompts, developer review of generated local pipeline and Fastlane files before committing them, and a consolidated Apple-signing form whose credentials TeamCity stores securely. The released workflow includes documentation, hosted TeamCity Cloud setup, pipeline monitoring, and analytics intended to identify user friction and guide future improvements.

JetBrains for Startups highlights stories from startup founders using JetBrains tools to build, launch, and scale their companies. Featured interviews include Synnax CEO and co-founder Emiliano Bonilla discussing rocket engine testing software, failed launches, and creating a programming language from scratch, alongside Oppex AI founder Prasun Kumar describing agent training through “chaos monkey” scenarios and his long experience with IntelliJ IDEA.

Prasun Kumar, CEO and founder of Oppex AI, describes the company’s AI agents for helping developers diagnose and resolve production incidents by assembling logs, cloud metrics, database health, affected-customer information, recent code changes, and prior fixes before an on-call engineer is alerted. Founded by Kumar, a longtime startup engineer and JetBrains user, the 15-person company has launched its product and begun working with enterprise customers, aiming to reduce mean time to resolve incidents to under 10 minutes. Oppex AI addresses the challenge of interpreting complex logs across large microservice environments by building system knowledge graphs and testing agents against a “chaos monkey” that deliberately breaks test systems. The team primarily uses IntelliJ IDEA alongside other JetBrains tools, with Kumar emphasizing IDEs’ value for understanding AI-generated code. Its long-term goal is to move from human-guided recommendations to human-approved fixes and eventually self-healing production systems.

JetBrains has updated its free RustRover-based adaptation of Mainmatter’s “100 Exercises to Learn Rust,” originally created by Rust author and consultant Luca Palmieri, offering an exercise-driven course for developers already familiar with another programming language. Across eight chapters, learners build a ticket management system while covering core Rust topics including ownership, borrowing, traits, error handling, collections, lifetimes, concurrency, and asynchronous programming, culminating in an open-ended challenge to create an asynchronous REST API. The update adds a redesigned introduction, an expanded FAQ, visible test assertions, a hands-on comparison of Cargo development and release overflow behavior, and a final project that lets learners select dependencies and verify API behavior through HTTP requests. Learners may also begin with the final challenge to identify knowledge gaps, while the course recommends using built-in AI chat for explanations and compiler-error guidance rather than generated code, with code completion disabled to preserve the learning experience. The course requires no manual setup, runs directly in RustRover with tests included, and is open source, while RustRover is free for non-commercial use.

JetBrains has introduced JetBrains Air, an open system of products intended to support agentic software development across individual developers, teams, and organizations while preserving oversight and accountability. The offering combines agentic capabilities in JetBrains IDEs, Air Teams for coordinating workflows involving people and autonomous agents, and Air Governance, formerly JetBrains Central, for policy enforcement, auditing, cost management, and visibility. JetBrains positions the platform as multi-vendor, using the Agent Client Protocol and ACP Registry to let developers use various compatible agents, models, and services without sacrificing organizational context or controls. The company argues that as AI makes code easier to generate, the central challenge shifts toward reviewing, verifying, coordinating, and taking responsibility for changes, particularly code that appears plausible but contains subtle flaws. Drawing on its code intelligence tools, JetBrains plans to provide agents with deterministic knowledge of codebases and extend Air into remote and mobile workflows, automated repository- and process-triggered tasks, richer organizational context, and cross-service governance.

JetBrains Qodana team members explain key software quality concepts and practices, distinguishing technical debt as a deliberate compromise that creates future work from poor code quality caused by issues such as insufficient knowledge. They recommend reducing cognitive complexity by avoiding deeply nested loops through extracted functions, simplified conditions, named intermediate results, functional constructs, and flatter data structures. Unit tests provide rapid feedback, catch regressions early, and make refactoring safer, while code coverage shows how much code tests execute and mutation testing assesses whether those tests can detect intentional code changes. Quality improvement should be measured through trends in static-analysis findings, technical debt, production-severity incidents, and mean time to recovery. The discussion also notes that automated analysis tools can produce false positives when they lack repository context, which teams can address through configuration exclusions or targeted inspection suppressions. Qodana is presented as a tool for incorporating JetBrains inspections into CI/CD pipelines to continuously identify bugs, vulnerabilities, dead code, and other quality concerns before they become more costly.

Junie /demo is a Junie CLI mode designed to automate interactive application checks after code changes by building and launching an app, navigating its interface, executing requested scenarios, and producing inspectable HTML reports, screenshots, and videos. Users can provide specific actions and expected outcomes, such as updating issue statuses and confirming persistence after a page reload, with clearer prompts improving the reliability of the demonstration. Generated videos include model-created introductory, scenario, and results slides, optional subtitles, and accompanying reports that show completed, failed, or incomplete checks. Junie /demo can also be integrated with GitHub Actions to attach demonstrations to pull requests or run repeatable release smoke tests, although workflows should require an explicit PASS verdict rather than treating process completion as success. It runs in a Debian-based Docker environment using Chromium, virtual desktop tools, and a Computer Use-capable model, with configurable templates for complex repositories and monorepos. Internal JetBrains use has produced thousands of PR demonstration videos and smoke tests, while reported model cost and speed comparisons are described as workload-specific rather than general guarantees.

Ktor 3.6.0 introduces experimental typed authentication, including role-based access, anonymous-user support, and specialized OpenID Connect integration with typed providers, sessions, browser login, and token refresh capabilities. The release also adds experimental HTTP/3 over QUIC for the Netty engine, alongside support for serving h2c and TLS-enabled HTTP/2 on separate connectors. Routing and request handling gain support for Kotlin UUID, byte, and unsigned parameter types, nullable receive operations, and a new partial HTML response function. Client-side improvements include more control over ContentNegotiation Accept-header merging and a Kotlin Multiplatform engine-defaults dependency that automatically selects suitable HTTP engines across targets, with cache storage now using kotlinx-io paths. Additional updates cover WebRTC for JVM, asynchronous DNS for CIO, OpenAPI tag descriptions, cookie parsing, and JavaScript fetch overrides.

Junie Local has introduced Qwen3.8-3.6-27B-blend, a 27-billion-parameter model created by equally merging related Qwen models to improve local coding-agent performance without the long reasoning times associated with Qwen3.8. In an internal 100-task coding benchmark, the blend completed 37 tasks, compared with 34 for Qwen3.6 and 39 for Qwen3.8, while producing 71% fewer output tokens than Qwen3.8; on shared successful tasks, it used roughly 279,000 tokens versus 935,000. Public benchmark testing also showed strong LiveCodeBench results, though visual tasks revealed that the blend can still spend additional tokens reasoning through difficult problems. The update includes runtime optimization research using multi-token prediction, where proposing two tokens per round provided a 60% decoding speedup on an M5 MacBook Pro, while a lower-memory four-bit prediction head performed similarly to an eight-bit version. Developers also identified and corrected evaluation instability caused by repeatedly using the same random seed, and the release is available for Apple M5 users, with experimental Windows support for newer NVIDIA RTX GPUs with at least 24 GB of VRAM.

JetBrains researchers propose the Artificial Intelligent Development Environments (AIDEs) Framework to explain the evolution of AI software tools and assess their future direction through three dimensions: stages of software creation, levels of delegation to AI, and organizational context. The framework argues that AI adoption is widespread but concentrated mainly in brainstorming and coding, while agentic tools are increasingly shifting developers from direct code editing toward planning, delegation, and review, with cloud agents beginning to handle limited autonomous tasks. It defines five delegation levels, from narrowly scoped tools such as code completion to AI “competence centers” that could manage entire development functions under human strategic oversight. The authors contend that delegation depends not only on model capability but also on human trust, context, and control requirements, and predict that developers will increasingly focus on requirements, architecture, governance, and business outcomes rather than code implementation. In this view, future software production may use AI as a scalable “intelligence resource” integrated across the full lifecycle, while humans remain responsible for specifying goals, supervising outcomes, and managing increasingly hybrid teams of people and AI systems.

JetBrains describes building Context, a production RAG system for semantic code search that helps coding agents find relevant repository code by meaning rather than relying on keywords or grep. The pipeline parses source files into structure-aware chunks using language-specific syntax rules, preserving relationships such as documentation, annotations, declarations, and closing syntax while avoiding both overly broad file-level results and contextless line-level fragments. It supports detailed parsing for nine major languages and uses simpler line-based splitting for others, with chunk quality evaluated by an LLM judge and end-to-end retrieval tests. Chunks, augmented with abbreviated file-path metadata, are converted into embeddings for similarity search; to reduce the large storage and comparison costs of millions of vectors, the system retains all embedding dimensions but binarizes them to one bit, using Hamming distance for efficient ranking. Although binary vectors reduce recall slightly and cannot reliably support absolute relevance thresholds, they are considered suitable for agent workflows that need a relevant group of results rather than perfectly ordered rankings. The platform uses separate deployment optimizations for high-throughput indexing and low-latency querying, runs open-weight embedding models on JetBrains-operated infrastructure, stores only file coordinates and metadata rather than source-code copies, and does not use customer code for training.

JetBrains has released Rider and ReSharper 2026.2.2, available through the IDEs, Toolbox App, website, and for Rider as a Snap package. Rider introduces an AI Agent Setup widget in the status bar that centralizes configuration for agent-related features such as MCP tools, skills, and hooks, while hook updates limit inspection feedback to agent-added code and provide formatting diffs for clearer context. Both Rider and ReSharper gain dotCover support for measuring TUnit test coverage, requiring the JetBrains.dotCover.Framework package and Microsoft.Testing.Platform 2.3.0 or later. Rider also fixes a macOS 26.2.2 issue that could indefinitely freeze the IDE during large solution loading, improves Unity Editor attachment for newer Unity Hub and custom builds, and enables MCP file operations across all folders attached to a solution.

IntelliJ IDEA 2026.2.3 is available through in-IDE updates, the Toolbox App, Ubuntu snaps, and JetBrains’ website. The release improves Maven tool window data loading for recently opened projects, resolves several IDE freeze causes, corrects the Markdown preview scrollbar, and updates the PlantUML extension to version 1.2026.6. It also fixes an issue that caused applications debugged with WSL2 mirrored networking to become unresponsive, while detailed fixes are available in the release notes and users can report remaining problems through the issue tracker.

JetBrains’ OpenTelemetry plugin includes a Service Map feature that uses live telemetry traces to automatically visualize how microservices, databases, and message queues interact at runtime, addressing the limitations of static architecture diagrams and code analysis. When an instrumented application is run from a supported JetBrains IDE, the plugin launches a local OpenTelemetry backend, receives spans, and incrementally constructs an architectural model that can be rendered in the IDE. Its stream-processing algorithm handles unordered and incomplete telemetry by classifying spans from semantic attributes, identifying services, and matching related client and server spans to establish cross-service connections, while applying different inference rules for database and messaging operations. Because it relies on OpenTelemetry semantic conventions rather than framework-specific APIs, the feature is language- and vendor-agnostic and can work across JVM, .NET, Python, Go, and other properly instrumented applications in IDEs including IntelliJ IDEA, GoLand, PyCharm, WebStorm, and Rider.

IntelliJ IDEA’s enhanced logpoints in version 2026.2 provide a non-suspending alternative to println logging and regular breakpoints, allowing developers to inspect and even temporarily alter a running Java application without rebuilding or redeploying it. Using a Dockerized gRPC server that incorrectly returns no discount for the JetBrains tenant, the walkthrough demonstrates attaching IntelliJ’s debugger remotely, adding logpoints dynamically, tracing the request flow, and identifying that the tenant name was not normalized before comparison. Logpoints avoid the timeout-related disruption caused by conventional breakpoints, which suspend gRPC server processing and can trigger request cancellation when client deadlines expire. The feature can also be used to test potential fixes and modify runtime values, such as extending deadlines only for tagged debugging requests, including within library dependencies. The walkthrough also highlights console-to-source navigation, cautions against expensive expressions in frequently executed paths, and describes an IntelliJ debugger AI agent skill that can help locate and modify relevant runtime behavior when developers lack familiarity with an underlying library.

JetBrains has released bug-fix updates for MPS 2026.1.1, 2025.3.2, 2025.2.4, and 2025.1.4, with downloads and detailed issue lists available for each version. MPS 2026.1.1 includes notable enhancements to the Projectional Agent Toolkit, enabling agents to access and invoke node-level intentions and quick-fixes, manipulate attributes, copy nodes, retrieve richer editor context such as caret and selection details, and receive diagnostics when modal dialogs prevent tool execution. The update also improves guidance for editor testing, YouTrack issue creation, and dependable test execution, while users are advised to update project MPS skills to take full advantage of the agent-related changes.

Java 27, released on September 15, 2026 under Java’s six-month cadence, includes nine JEPs: four finalized features, four continuing preview features, and the Vector API as an incubator module. Its stable changes make G1 the default garbage collector in all HotSpot environments, add post-quantum hybrid key exchange for TLS 1.3, enable compact object headers by default to reduce memory use, and introduce in-process redaction of sensitive data in Java Flight Recorder recordings. IntelliJ IDEA provides day-one Java 27 support, including JDK downloads, automatic configuration through SDKMAN! or asdf files, preview-feature highlighting, terminal JDK propagation, and tooling for run options and concurrency templates. Preview features include revised lazy constants, primitive patterns in `instanceof` and `switch`, structured concurrency, and PEM encoding APIs for cryptographic objects, while the Vector API remains experimental and requires explicit module activation. Java 27 also improves debugger stepping performance, with a related fix backported to JetBrains Runtime 25, and points toward Java 28 previews for Project Valhalla features such as value objects and strict field initialization.

JetBrains Toolbox App 3.8 improves update reliability, keyboard accessibility, and cleanup visibility. On macOS, the app now keeps manual IDE updates available when the operating system incorrectly identifies an installation directory as protected, while providing instructions if an update is actually blocked. Windows users can again navigate Tools and Projects with Ctrl+1 and Ctrl+2 and move through filtered or long lists using arrow, page, home, and end keys. The release also adds detailed progress indicators for removing leftover IDE directories and prevents duplicate cleanup actions until deletion and rescanning are complete.

The Zephyr Project community will hold a free in-person meetup at JetBrains Amsterdam on September 15, 2026, bringing together embedded developers, contributors, users, vendors, and others interested in the open-source real-time operating system for connected, resource-constrained devices. The English-language event will include talks from JetBrains, Vicentra, and Schematik on Zephyr adoption, firmware fuzzing with AFL and Renode, AI-assisted project setup, and a migration of a medical simulation platform from bare-metal and FreeRTOS to Zephyr across multiple hardware targets. The program also includes refreshments, networking, a quiz, development-board giveaways, and an opportunity to win a Nordic Semiconductor nRF54L15 Tag. Registration is required because attendance is limited.

A Rust Foundation livestream introduced Rig, an open-source Rust library that provides a unified interface for large language model providers such as OpenAI, Anthropic, and Gemini, helping developers build applications without depending on provider-specific APIs. Rig structures applications around provider clients, models, agents, preambles, and Rust-based tools that can perform tasks such as file operations, database queries, calculations, or shell commands, with support for asynchronous requests, streaming, agent delegation, and stateful tool context. The session demonstrated these capabilities through Rat Code, a terminal coding agent built with Rig and Ratatui that registers file and shell tools and streams model responses in its interface. Rig also supports retrieval-augmented generation through vector-store integrations and local inference through Ollama, llama.cpp, and Candle, including options to embed model weights or run supported models in WebAssembly. To test changing provider integrations despite nondeterministic model outputs, Rig records live HTTP interactions as cassettes that can be replayed in CI, while production users may separately schedule live-model tests to assess output quality.

JetBrains has added Google’s Gemini 3.8 Flash coding model to its Junie IDE plugin and CLI, offering a limited-time 75% introductory discount with no setup or waitlist required. Positioned for complex, long-running engineering tasks, Gemini 3.8 Flash uses a more deliberate agentic workflow than Gemini 3.7 Flash, breaking work into subtasks, exploring codebases, reproducing bugs, running tests, and verifying changes before completion. Google reports that the model performs strongly on the DeepSWE v1.1 benchmark for long-horizon software development while remaining less costly than many larger frontier models, although Gemini 3.7 Flash remains available as a lower-cost option for smaller fixes and refactoring tasks.

JetBrains is standardizing WSL project support around a new Native mode, recommended from version 2026.2 for IntelliJ IDEA, WebStorm, and PhpStorm, in which the IDE remains a Windows application while a lightweight IJent agent operates inside WSL to handle Linux files and processes. Earlier approaches had notable drawbacks: 9P filesystem access and WSL-specific command handling caused latency, poor throughput, antivirus-related slowdowns, and symlink issues; WSLg provided an unsupported Linux GUI workaround with integration limitations; and Remote Development placed the backend in WSL but required a large installation and incurred ongoing client-server synchronization costs. IJent, written in Rust and using portable stdio or faster Hyper-V sockets, executes operations with correct Linux filesystem semantics and avoids reliance on 9P, while EelApi abstracts local and remote environments for IDE code and plugins across WSL, Docker, and Dev Containers. Benchmarking a large Spring project showed Native mode reduced ready-to-work time by 38%, project-tree scanning by 54%, file-content reads by 53%, and indexing time by 22% compared with 9P, although small projects showed no measurable difference.

YouTrack is hosting live webinars for organizations considering migration from Atlassian products, following Atlassian’s discontinuation of Data Center sales and support. The main English-language session will take place on September 30, 2026, on YouTube and will cover migrating projects, users, and data from Jira, Confluence, and Jira Service Management, alongside live demonstrations, deployment and pricing options, customer stories, and consulting support. Intended for administrators, project managers, and team leads, the event will demonstrate how YouTrack combines project management, documentation, and customer support. Regional sessions include a Japanese Zoom webinar on September 30 addressing project management, workflow automation, AI agent connections through MCP, and Jira migration, as well as a Russian-language session hosted by Noventiq on October 28 for audiences in Central Asia, the Caucasus, and Eastern Europe. Organizations can also book migration consultations, access a practical migration guide, and review YouTrack subscription options, which the company says may reduce ownership costs by up to 80% compared with Jira and Confluence.

JetBrains investigated reports that ReSharper’s out-of-process architecture, despite generally improving IDE responsiveness, caused unexpectedly slow cold starts on Windows because Microsoft Defender performed extensive scanning of its separate process, sometimes adding tens of seconds. Using Defender ETW logs and CPU-time measurements across repeated cold-start tests, the team found that IDEs and editor-class tools could face 10–40 seconds of scanning while Microsoft IDEs and command-line tools were typically scanned in under two seconds, with write-protected installation directories receiving more favorable scanning treatment. Collaboration with Microsoft clarified Defender’s behavior and led to Defender version 1.449.454.0 optimizations that improve ReSharper OOP and Rider performance when installed in write-protected paths, although JetBrains Toolbox’s user-writable installation location may still incur overhead that exclusions can partly reduce. JetBrains released its Defender Performance Tool on GitHub to help developers inspect real-time or recorded Defender scan activity, and recommends keeping Defender updated, using Microsoft’s performance-recording PowerShell tools, considering write-protected installation paths or approved exclusions, and using Dev Drives for repositories and package caches; ReSharper 2026.2.1 now enables OOP mode by default.

IntelliJ IDEA Ultimate 2026.2 introduces Spring Security inlays through its Spring Debugger plugin to help developers inspect effective HTTP authorization requirements and temporarily bypass them during an active debug session without editing configuration or restarting an application. The inlays display runtime role or authority rules derived from the live SecurityFilterChain, link to relevant configuration, and can unlock a precise URI and HTTP method either with its required roles or with custom credentials and authorities. Unlocking injects a temporary TestingAuthenticationToken into Spring Security’s context at AuthorizationFilter, allowing normal downstream authorization evaluation while preserving protections such as CSRF checks; however, it affects every client reaching the unlocked endpoint and should be used cautiously, particularly on network-accessible or remote applications. The feature is limited to Servlet-based Spring Security authorization, requires an active debugger, does not support WebFlux or legacy FilterSecurityInterceptor configurations, and may not work with custom principal types or @AuthenticationPrincipal parameters. Method-level security is not directly unlocked but can pass when the injected authorities satisfy its checks, while planned future MCP support may enable automated workflows to inspect and unlock endpoints programmatically.

WebStorm 2026.2.2 provides stable support for TypeScript 7’s Go-based language engine, offering faster coding assistance for Angular and React projects without requiring teams to upgrade the TypeScript version used by their project infrastructure. The new engine replaces the previous Node.js language service and is reported by Microsoft to compile up to ten times faster; WebStorm testing on the Kibana codebase reduced project load time from about 12 seconds to 3 seconds. Angular support is enabled through WebStorm’s Kotlin-based template transpiler and adapted Volar source-mapping infrastructure, allowing assistance in inline templates despite current limitations in TypeScript-Go content mappers and the Angular compiler’s lack of native TypeScript 7 support. React support is stable and available by selecting TypeScript 7 in WebStorm preferences, while Vue support remains under development as JetBrains evaluates whether to use official content mappers or a Kotlin-based transpiler solution.

JetBrains’ September 2026 dotInsights newsletter, curated by Rachel Appel, highlights recent .NET and software development resources alongside the note that the open-source C# Roslyn compiler is itself written in C# and provides code-analysis and generation APIs. Its linked coverage spans .NET 11 performance and security features, Azure Service Bus filters, ASP.NET Core authentication and CSRF protection, code obfuscation, digital signatures, URI and IP-address handling, Blazor CSV and search capabilities, .NET MAUI UI development, Orleans and DocumentDB, Kubernetes memory optimization, architecture patterns, and local AI models. The issue also examines AI-assisted development, including coding-agent workflows, risks, user-experience patterns, and the role of engineers, while JetBrains announcements promote GameDev Day, .NET Day Online, the Rider 2026.3 Early Access Program, Rider and ReSharper updates, and AI-agent access to Rider’s refactoring engine.

Java Annotated Monthly for September 2026 surveys Java ecosystem news, tutorials, tools, community topics, and upcoming events, with a featured contribution from Java engineer Aicha Laafia focused on JDK 27. The release includes nine JEPs, with compact object headers enabled by default to reduce heap usage and improve throughput, while G1 becomes the default garbage collector across all environments, prompting caution for smaller containers. The issue also tracks developments including Project Valhalla, a proposed simple JSON API for JDK 28, cryptography, Java migrations, profiling, virtual threads, structured concurrency, and retrieval-augmented generation. Additional sections highlight Kotlin’s open-source AI work, JetBrains’ AI and IDE initiatives, enterprise adoption of agentic AI, updates across Spring, Gradle, Hibernate, Kubernetes, Maven, and a schedule of developer conferences worldwide.

Kotlin 2.4.20 introduces enhancements across its ecosystem, including coroutine stack-trace recovery and additional collection and testing utilities in the standard library. Kotlin/Native gains expanded Swift export capabilities, faster incremental compilation, and automatic Package.swift generation, while Kotlin/Wasm improves JavaScript interop behavior, initialization ordering, and Wasmtime support through the Gradle plugin. Kotlin/JS adds a browser-testing DSL, async exports for suspend lambdas, and better data-class exportability, alongside Gradle 9.7.0 compatibility and improved Problems API reporting. The release also expands the Build Tools API to Kotlin/JS, Kotlin/Wasm, and metadata targets, and adds the kotlinr runner command and a separate native image for the compiler. Kotlin 2.4.20 is available through updated IntelliJ IDEA and Android Studio installations, build-script version updates, or the command-line compiler release on GitHub.

JetBrains has opened the Early Access Program for Rider 2026.3, with the first build available through its website and the Toolbox App. Key additions include optional rainbow brackets that color matching brackets by nesting depth, simplified data breakpoint creation through editor context menus and the Breakpoints window, and a consolidated Game Development plugin category covering bundled tools such as Unity Support, UnrealLink, and Godot plugins. Code completion now offers filters for suggestion types including namespaces, classes, enums, and events, while dotCover integration adds test coverage support for TUnit projects using the required JetBrains and Microsoft Testing Platform packages.

Kotlin Toolchain 0.12.0 expands its alpha-stage multiplatform development capabilities with publication support for libraries targeting JVM, Android, iOS, and Wasm, including platform artifacts, metadata, sources, and C interop bindings. The release introduces preview support for building and running Wasm web applications, improves Compose Hot Reload through command-line controls and an MCP server for agent interaction, and reduces default Maven Central publication files to better meet anticipated quota limits. IDE enhancements in IntelliJ IDEA 2026.2.1 include Compose previews, improved resource handling, Android tooling features, more configurable iOS run settings, Kotlin/Swift interoperability fixes, and dependency-coordinate hints. Other changes include a project-root-relative local dependency syntax using `//`, a minimum requirement of JDK 17 and Kotlin 2.2.20, updated default framework versions, and production adoption of the toolchain by klibs.io.

Python educator Ardit Sulce argues that generative AI has shifted programming education by handling many routine learner questions while increasing the importance of teachers as guides who provide structure, context, and judgment. He maintains that beginners should continue to manually write code and work through conceptual challenges, while using AI to remove unproductive technical friction such as setup issues. Sulce suggests that learning and hiring should emphasize explaining, reviewing, and debugging code rather than simply producing functioning programs, and identifies code reading, precise specification writing, and system-level understanding as key skills for junior developers. He also advocates learning in professional IDEs such as PyCharm, where students can practice managing real projects, dependencies, configuration, debugging, and AI-generated changes. His proposed learning path moves from writing basic syntax manually, to using AI as a tutor on increasingly complex projects, and eventually supervising AI as a co-worker, with the goal of building the system understanding needed for modern software development.

Go treats errors as ordinary values returned alongside function results, requiring callers to check and either handle, log, or propagate them, usually with the error as the final return value. The guide explains creating errors, adding diagnostic context with `fmt.Errorf` and `%w`, preserving error chains for inspection through `errors.Is`, `errors.As`, and Go 1.26’s type-safe `errors.AsType`, as well as collecting multiple failures with `errors.Join`. It distinguishes routine, expected failures such as invalid input, missing files, I/O problems, and network interruptions from exceptional conditions appropriate for `panic`, while describing `recover` as a limited mechanism for keeping services alive after isolated panics. It also covers context cancellation causes, deferred resource cleanup, custom error types, retry strategies for temporary network errors, and I/O semantics including `io.EOF`. Recommended practices include never ignoring returned errors, providing specific contextual information, choosing libraries with reliable error behavior, logging errors at an appropriate application layer, and avoiding `log.Fatal` outside `main` because it bypasses deferred cleanup.

JetBrains has launched the MPS 2026.2 Early Access Program, introducing improvements to editor testing, result organization, node selection, and startup configuration alongside numerous bug fixes. Editor tests can now use customizable node-matching rules or per-node markers to ignore irrelevant differences, while failure messages identify the affected nodes and editor cells with detailed presentation information. Find Usages results can be grouped by virtual package, mirroring Project view folder structures, and the Select Up command now selects sibling-node lists before moving to parent nodes, making multi-node editing more predictable. The release also aligns MPS launcher configuration more closely with the IntelliJ Platform by separating platform and MPS-specific classpaths, incorporating platform JVM options, and applying operating-system-specific access settings more precisely.

IntelliJ IDEA 2026.2.2 is available through the IDE, JetBrains Toolbox App, Ubuntu snaps, and the JetBrains website, delivering a set of bug fixes and usability refinements. The update resolves failures when loading remote OpenAPI specifications, preserves terminal tab order after projects are reopened, improves Markdown checkbox contrast and scrollbar rendering, and prevents freezes when opening folders with many Markdown files. It also fixes incorrect Spring Modulith accessibility warnings involving types exposed through @NamedInterface in nested modules, while full issue details are available in the release notes and users are encouraged to report further bugs through the issue tracker.

CLion 2026.2.2 introduces clion-embedded-hardfault, an AI debugging skill that helps diagnose ARM Cortex-M hard faults by using MCP-based access to decoded fault registers, exception frames, memory, disassembly, and peripheral register data. Designed to reduce the manual work of interpreting CFSR and HFSR registers, locating faulting instructions, and reproducing crashes, the skill traces faults to their likely source and can suggest or apply fixes before rerunning debugging sessions for verification. It is vendor-agnostic, supporting tools such as Lauterbach TRACE32, Segger J-Link, and ST-LINK, and activates when debugging stops in common fault handlers or when relevant fault-register terms are mentioned. The feature is enabled by default but requires CLion’s MCP server to be turned on, works in AI chat and CLI modes for Claude Code and Codex, and is currently limited to CLI mode for GitHub Copilot. Its underlying tools also provide agents with broader debugging capabilities, including control of sessions, breakpoints, stepping, and inspection of variables, memory, registers, and disassembly.

TeamCity 2026.2 makes its YAML-based pipelines generally available for both Cloud and On-Premises deployments after an early-access period, adding stronger branch and protected-branch handling, failure-tolerant dependent jobs, promotion of completed pipeline runs, individual job debugging, and pipelines without connected repositories. The release expands AI capabilities through Bring Your Own Key support for AI Assistant, allowing organizations to use supported cloud models or local LLMs, while new MCP tools enable AI agents to retrieve, create, and delete pipelines, with write actions restricted to manually enabled Brave mode. It also introduces OAuth/PKCE authorization for MCP integrations, configurable retries for failed dependencies in build chains, and improved IntelliJ IDEA plugin functionality for test results, remote runs with uncommitted changes, MCP registration, and iOS build and TestFlight workflows. Additional updates include GitHub pull-request matching by source branch and a choice to compile Kotlin DSL settings on either the TeamCity server or build agents, alongside maintenance releases for earlier On-Premises versions.

TeamCity’s OIDC JWT plugin enables CI/CD builds to authenticate with external services such as AWS and Google Cloud using short-lived OpenID Connect tokens rather than static credentials, reducing risks from leaked secrets, sharing, and credential rotation. OIDC works by having an identity provider issue signed JWTs containing claims such as issuer, audience, and expiration, which token consumers validate through public signing keys published in a metadata document and JWKS before granting workload access or exchanging tokens for temporary credentials. The plugin allows TeamCity to act as an identity provider, supports RSA and ECDSA signing, key rotation, configurable issuer URLs for private instances, and extensibility for external key systems such as HSMs or cloud KMS services. Available for TeamCity 2025.11 and later with Java 17, it can issue tokens as build parameters at build start with configurable lifetimes or generate fixed five-minute tokens on demand through HTTP requests for long-running builds, with audiences and setup requirements determined by each destination service.

Public sector software projects must maintain code compliance to protect sensitive citizen data, meet legal and contractual obligations, and avoid the financial, operational, and reputational consequences of breaches or audit failures. Key risks include weak security controls such as hardcoded credentials, insecure input handling, outdated cryptography, and vulnerable third-party dependencies; procurement and contract violations involving missed service levels or incompatible open-source licenses; inadequate audit evidence caused by reliance on manual reviews; long-term supportability problems from technical debt, unsupported libraries, and contractor handovers; and IT governance breaches involving unsuitable cloud or SaaS dependencies. The article argues that security, privacy, accessibility, supply-chain controls, and maintainability should be embedded throughout the software development lifecycle rather than addressed late in testing. It recommends automated static security analysis, secret and dependency scanning, license checks, quality gates, testing, technical-debt tracking, and time-stamped audit reports in CI/CD pipelines to provide consistent enforcement and traceable evidence, while noting that self-hosted or air-gapped tools may be needed where government infrastructure policies restrict external services.

The Grails plugin for IntelliJ IDEA has transferred from JetBrains to the Apache Grails project, placing its source code, development, releases, and Marketplace publishing under the oversight of the Apache Grails Project Management Committee. The plugin continues to provide Grails-specific coding assistance, GSP tooling, and GORM integration, while allowing its development schedule and compatibility updates to align directly with the Grails framework roadmap rather than IntelliJ IDEA release cycles. Build 262.0.0, supporting IntelliJ IDEA 2026.2, is already available, and existing users do not need to migrate because the plugin ID remains unchanged. However, beginning with IntelliJ IDEA 2026.2, the plugin is no longer bundled with IntelliJ IDEA Ultimate by default and must be installed from JetBrains Marketplace under the Apache Grails listing if needed. JetBrains will continue to host and feature the plugin on Marketplace, collaborate with the Grails team, and provide advance notice of relevant platform API changes.