DoorDash is opening a limited beta of dd-cli, a command-line tool that lets developers and AI agents search stores, build carts, and place orders from the terminal, marking another step toward software designed for AI agents instead of just humans.

Autonomous agent or 'autopilot' – touted for executing high-level autonomous tasks – now offers improved usability and model choice.

The post Enhancements to Microsoft Scout Increase AI Model, Chat Navigation Flexibility appeared first on Cloud Wars.

With a debugger skill for AI agents, debug profiles for simplified debugger configuration, and support for C++26 reflection.

CLion 2026.2 is now available. This latest version of the JetBrains IDE for C and C++ includes the following key features:

• New bundled skill for agentic debugging.
• Support for STM32 Cube CLI, a new ST bundle manager.
• Simplified debugger configuration with debug profiles.
• Support for C++26 reflection.

You can download CLion 2026.2 from the link below, via the Toolbox App, or as a snap package if you’re using Ubuntu, or apply a patch update from version 2026.1.

DOWNLOAD CLION 2026.2

Debugger skill for AI agents

CLion 2026.2 introduces a bundled skill that gives AI agents direct access to the debugger. Agents can use stack traces, breakpoints, and variable values to investigate root causes without interrupting their autonomous workflow.

The skill works with GDB, LLDB, and DAP-based debuggers and is available for agents compatible with the ACP (Agent Client Protocol). To invoke it, use /clion-debugger in Claude Code or $clion-debugger in Codex. We plan to add more embedded-related debugging features in a future update.

Embedded development

Support for the STM32 bundle manager

Setting up an STM32 embedded-development environment currently requires installing the all-in-one STM32CubeCLT package, even if you only need specific tools or a particular bundle version. CLion 2026.2 adds support for STM32 Cube CLI, a new STM32 bundle manager that lets you download only the tools you need – such as CMake, ST-LINK GDB server, or GNU tools – and manage your development bundles directly in the IDE.

You can use STM32 Cube CLI in the terminal or via Tools | STM32 Cube CLI. The IDE also supports installing project bundles to all environments at once when working with toolchains over WSL or SSH. When required bundles are missing, CLion shows a notification in the CMake output with a one-click action to install them. More options are expected in CLion 2026.3.

Support for structs and arrays in live watches

With live watches, you can monitor global variables in real time – no need to stop the debugger or interrupt a program’s execution. In this release, we’ve extended the support for variable types, making it possible to inspect arrays and structs. A new button also lets you clear the variable value history to keep the view focused on the current data.

Debugger

Simplified debugger configuration with debug profiles

Previously, configuring the debugger meant dealing with different IDE settings. This became even more complicated for embedded projects, which add extra layers like hardware interfaces and probes.

In 2026.2, there’s a new settings section that provides a single place to configure all your debugging setups – local, remote, and embedded. Whether you’re using GDB, LLDB, SEGGER J-Link, or ST-LINK, everything is now consolidated in Settings | Debugger | Debug Profiles.

Easier inspection of fields and global variables

When debugging, CLion automatically tracks local variables in the Threads & Variables pane. To inspect fields and global variables, you previously had to set up watches manually, which added friction when they were just as relevant to the current context.

CLion 2026.2 introduces a new debugger setting that automatically displays fields and global variables alongside locals, while keeping them visually distinct. This feature is enabled by default. You can disable it in Settings | Build, Execution, Deployment | Debugger | Data Views | C/C++ | Variables.

Configuration-specific breakpoints

When debugging multiprocess systems or working with different target platforms, managing breakpoints across configurations can be cumbersome. Breakpoints set for one process or target may be triggered unexpectedly in another. 

CLion 2026.2 introduces a feature that makes it easier to isolate and diagnose issues in these cases. You can now assign breakpoints to a specific debug configuration in the Breakpoints dialog (Run | View Breakpoints). When that configuration is active, the debugger stops only at its assigned breakpoints and ignores the rest.

Support for Natvis on Linux and macOS

Previously, users on macOS and Linux had to write Python data formatters for LLDB to improve type visualization in the debugger – a time-consuming, error-prone process. CLion 2026.2 adds Natvis support for macOS and Linux, eliminating this requirement. All you need to do now is describe how your type should look in a few lines of your Natvis file, and CLion’s debugger handles the rest.

The feature is available for projects with .natvis files located in the project root and additional directories specified in the IDE settings. It also works only with the bundled LLDB or a custom one; if you’re using a custom LLDB, ensure it includes Python 3.10 or later.

To enable Natvis rendering, go to Settings | Build, Execution, Deployment | Debugger | Data Views | C/C++ and turn on Enable Natvis renderers for LLDB.

Natvis support is also available in Rider – read the Rider team’s blog post to learn more.

Build tools and project formats

Improvements to Bazel support

It’s been almost a year since we took over the development and maintenance of the Bazel for CLion plugin from Google, and we remain committed to providing a stable, fast, and intuitive Bazel experience. In this release, the plugin has received several improvements:

• When starting a debug session, CLion now checks whether your project is built with debug symbols instead of automatically injecting debug flags. If debug symbols are missing, the IDE shows a warning, from which you can inject debug flags directly. The debug session will then continue.

• You can now switch configurations when multiple exist for the same file. Before, this was only possible for users of the legacy CLion Classic engine.
• The plugin automatically selects the correct configuration when you debug or run a target, ensuring your code insight always reflects the active target.

Easier CMake target renaming

CMake targets are executables, libraries, and utilities created with commands such as add_executable or add_library. Previously, renaming a target in CLion required manually editing all its occurrences. Now, you can rename targets in your CMakeLists.txt files automatically using the Rename refactoring action (Shift+F6). It updates all definitions and usages of the target name across your project.

Bundled toolchain updates

We’ve updated several tools shipped with CLion:

• CMake updated to v4.3
• GCC updated to v15.2.0
• GDB updated to v17.1
• Mingw-w64 updated to v13

Language updates

Support for new C++ features

C++26 reflection: Compile-time reflection in C++26 is one of the most significant additions to the language in years. Previously, you might’ve had to write tedious boilerplate where code needed to inspect or iterate over types, functions, or members during compilation – for example, to list struct members or convert enum values to strings. C++26 reflection reduces this repetitive code by giving programs a standard way to access information about types, functions, variables, and other declarations at compile time.

CLion 2026.2 adds highlighting and code analysis for reflection, available when using GCC 16.1 or newer. With this addition, the IDE now supports most C++26 features – learn more in our blog post.

Reflection-related features: Support for reflection is complemented by two related C++26 language features:

• The IDE now supports consteval { ... } blocks, which are evaluated at compile time and can inject declarations into the enclosing scope. consteval blocks provide a clean way to trigger compile-time side effects, making them particularly useful for practical metaprogramming with reflection.
• User-defined annotations can now be attached to declarations and queried via the reflection API, enabling custom metadata-driven code generation.

constexpr evaluation: Clion 2026.2 extends its constexpr evaluator with two important capabilities:

• The evaluator now supports dynamic memory allocation during constant evaluation – a feature introduced in C++20. This enables the correct evaluation of constexpr code that uses new/delete or standard containers like std::vector and std::string.
• The evaluator now also supports C++26 constexpr exceptions and handles try/catch and throw expressions during constant evaluation.

Removing the CLion Classic engine

CLion Classic, the legacy C and C++ engine, has been unbundled from the IDE and is now available only as a plugin on JetBrains Marketplace. This completes our transition to CLion Nova, which is now the default engine for everyone. To learn more about the reasons for this decision, read our blog post.

To continue using CLion Classic, install the C/C+​+​ Language Support via Classic Engine plugin from Settings | Plugins | Marketplace. Note that CLion Classic is no longer in development – all new language features are developed exclusively for CLion Nova.

Other updates

Git improvements

• Streamlined Git conflict resolution: In large projects, merges often result in dozens of conflicts. Resolve All Simple Conflicts is a new action that automatically resolves standard conflicts across the entire changeset at once, rather than opening each file individually. The new flow also provides an overview of resolved and unresolved files.

• Enhanced Git worktree support: You can now use worktrees in WSL environments, clean up pruned worktrees directly from the IDE, and take advantage of more reliable worktree deletion scenarios.
• Username autocomplete in code reviews: Type @ in a code review comment to get autocomplete suggestions for usernames from your GitHub or GitLab repository.

Terminal improvements

• Drag-and-drop file and folder support: You can now drag a file or folder directly into the terminal to insert its path into the current command, or drop it onto a terminal tab to open a new tab rooted at that location. You can also paste images from the clipboard directly into supported CLI agent sessions.

• Faster MCP setup: When you start a new AI session in the terminal without an MCP server configured, CLion now prompts you to set one up and takes you directly to the relevant settings.

What’s fixed

Here are some of the notable fixes in this release:

• Better UI for external sources in the Project tool window: When external source files share names with your project’s sources, telling them apart in the Project tool window can be difficult – especially in embedded projects with long file paths. CLion 2026.2 groups all external sources under a dedicated node, making them easy to distinguish from your project’s files.

• Asynchronous file writes: File saves no longer block the UI thread, reducing freezes during save operations, especially in WSL and Docker environments. If you’re a plugin developer, refer to the dedicated blog post for migration guidance.
• Deprecating the Machine Learning Code Completion plugin: With AI completion, next edit suggestions, and agents now covering intelligent assistance, the ML-based completion ranking plugin is no longer bundled. It remains available on JetBrains Marketplace if needed.

Try CLion and tell us what you think

We invite you to give CLion 2026.2 a try. If you have an active subscription, you can update it right away. New to CLion? You can use the IDE for free on non-commercial or educational projects. Otherwise, just start a free 30-day trial to access all the latest features and improvements.

We value your feedback! If you have anything to share or if you run into any problems, please let us know in the comments below, on X, or via our issue tracker.

DOWNLOAD CLION 2026.2

The chat client that brought Comic Sans to the world is now on GitHub

Today, we’re excited to announce the open-source release of Microsoft Comic Chat, the chat client that automatically turned conversations within Internet Relay Chat (IRC) into comic panels featuring illustrated characters, speech bubbles, and expressions, and helped introduce the world to a little font called Comic Sans.

Yes, that Comic Sans. Originally designed by Microsoft typographer Vincent Connare in 1994, Comic Sans found its first real home in Comic Chat, where its informal, hand-lettered feel matched the software’s speech-bubble conversations perfectly.

For many people, Comic Chat is a nostalgic artifact from the early days of the internet as we transitioned from technologies like telnet, Usenet, and IRC to the largely visual web that we enjoy today. For others, it’s a legendary piece of Microsoft history they have only heard about in stories, screenshots, and debates about typography. Now, developers, historians, retro computing enthusiasts, and anyone who appreciates a wonderfully unconventional idea can explore the source code for themselves.

A different vision for online communication

Today we’re accustomed to messaging apps with reactions, stickers, GIFs, avatars, video, and AI-generated content. But in the mid-1990s, internet chat was largely walls of scrolling text.

Rather than displaying messages as plain text, Comic Chat presented participants as illustrated characters. Conversations unfolded in comic panels, with speech bubbles, expressions, and gestures generated from what people typed. If someone wrote “I like that,” the character might point to itself. If the text suggested anger, the character might frown or cross its arms. It was quirky, ambitious, occasionally chaotic, and surprisingly forward-looking.

Many ideas we now take for granted in online communication can trace some of their spirit to experiments like Comic Chat.

The people who built it

David “DJ” Kurlander, working in the Microsoft Research Virtual Worlds Group, conceived the idea of a new visual representation of conversational histories, and started developing Comic Chat in 1995. Built in Visual C++ 4.0 and MFC, Comic Chat was released in 1996 with the Internet Explorer 3 web browser.

Under the hood, Comic Chat was more than a clever skin for IRC. It was able to interpret conversational cues in the text and choose appropriate poses, facial expressions, gestures, and panel layouts. That meant Comic Chat was not simply displaying messages but also making real-time editorial decisions about how a conversation should look and feel as a comic. DJ, Tim Skelly, and David Salesin published a paper on the technology in Comic Chat at SIGGRAPH ’96, a computer graphics conference, describing what they had built as an experiment in automatic illustration construction and layout.

The visual world of Comic Chat was the work of Jim Woodring, a highly regarded independent comic artist whose characters gave the software its distinctive look. The team would hand Jim transcripts of real chat sessions to illustrate, then use the results to figure out whether the whole idea was worth pursuing. It was.

Why open source it now?

Comic Chat represents a fascinating chapter in the evolution of online communication. It emerged during a period when the internet was still discovering what it wanted to become. Many rules had not yet been written, which gave developers permission to try bold concepts that might seem unusual even today.

By releasing Comic Chat as open source, we’re preserving an important piece of software history and giving the community an opportunity to explore, learn, and build upon it.

The source is available now for exploration, study, and experimentation. Alongside the original snapshots, we’ve included a few AI-powered modernization attempts that demonstrate what’s possible—getting this 1990s-era C++ and MFC code building with current Visual Studio tools, connecting to modern IRC servers, and running legibly on today’s high-resolution Windows machines. These are not polished re-releases, but worked examples that show Comic Chat can still come alive on modern systems. We’re excited to see what improvements, ports, experiments, and entirely new forms the community brings to it next.

A time capsule of internet optimism

Looking back, Comic Chat captures something special about the era in which it was created.

The early web was filled with experimentation. “What if chat rooms looked like comics?” That question sounds wonderfully unreasonable. And yet it was built, shipped, localized into 24 languages, and bundled with Windows 98.

That’s part of what makes Comic Chat memorable decades later. It reminds us that innovation often starts with ideas that are playful, unconventional, and creative.

One last speech bubble

Comic Chat was created during a period when software teams were willing to color outside the lines, literally and figuratively. DJ Kurlander, Tim Skelly, David Salesin, Jim Woodring, and everyone else who touched this project made something that people still remember and still run thirty years later.

Take a look at the source code, explore what they built, and use its story as inspiration to come up with new unconventionally delightful things to create.

And if you happen to read the source code in Comic Sans, we promise not to judge.

The post Microsoft Comic Chat is now open source appeared first on Microsoft Open Source Blog.

DataGrip 2026.2, the second major update of the year, is here! Let’s take a look at what’s inside.

AI

This release introduces three AI agent skills for working with databases: database-tools, database-connection-management, and database-text-to-sql. Together, they let AI agents explore and query connected databases, configure and update database connections, and generate SQL based on your database schema directly from the AI chat. The skills also include the corresponding MCP tools, so no additional setup is required.

To help agents work with data source management tasks, we’ve added two new MCP tools – create_database_connection and edit_database_connection – and included them in the database-connection-management skill. With these MCP tools and the new skill, you can, for example, ask an agent to create a new data source in chat, providing the connection details in your prompt.

Next up is an update for those who work with AI agents in CLI. Now, before performing an operation on a database, an agent asks for your consent and shows you what it is about to do. SQL queries are syntax-highlighted for better readability:

This release also brings a number of smaller enhancements that make AI-assisted database workflows smoother and more reliable:

• AI Assistant now remembers query results from previous interactions, so you can fetch additional rows without rerunning the query.
• When an AI agent creates a database object, it appears in the Database Explorer right away.
• AI agents are now better at resolving database objects. They can distinguish between objects that don’t exist and objects that haven’t been introspected yet.
• Queries executed by AI agents are now included in the data source query history, making it easier to review AI-generated SQL alongside your own queries.
• When an SQL query fails, AI agents now receive the database’s actual error message instead of a generic error, allowing them to respond more accurately.
• The list_database_connections MCP tool no longer returns an output schema error when parameters with default values are provided.

We’ve also redesigned the schema attachment UI in the AI Chat tool window and removed the AI Assistant plugin requirement for database-specific MCP tools.

A smoother start

We’ve reworked the first steps a user takes in the IDE. The Welcome screen that you saw when starting DataGrip for the first time or after closing all projects – it used to be a modal dialog, but now it is a regular IDE tab. You can have it open and use the IDE at the same time. This new Welcome tab appears in the default project.

In this release, we’re also introducing an interactive onboarding tour. The tour shows you around the essential UI areas and walks through the IDE’s core features. It demonstrates key actions in the Database Explorer tool window, the data source settings dialog, query execution in a query console, viewing and working with query result sets, and submitting changes to a database.

CLI commands for data sources

Now you can perform some actions on data sources in a command-line interface (CLI). We’ve introduced the list and manage commands that allow you to manage your connections and drivers. The syntax is:

datagrip dataSources <command> [options] [arguments]

In this interface, a batch-processing approach is used. It means you can pass a JSON file containing multiple instructions instead of running one command per action. The tool processes them in a single session and returns the results in JSON, making it perfect for shell pipelines.

Connectivity

Now there are three session control modes for you to switch between, depending on how you want to divide database connection sessions between clients (query console, data editor, and so on):

• Single shared session mode supports scenarios where you want to share a single connection across multiple clients.
• Two sessions: shared and introspection creates two sessions: one for introspection and the other for everything else.
• Dedicated sessions creates a new session for each client.

To help you create data sources more quickly without waiting for a JDBC driver to be downloaded, we’ve bundled a few drivers with the IDE. Now, DataGrip includes the following drivers:

• Microsoft SQL Server ver. 13.2.1
• MongoDB ver. 1.21
• MySQL Connector/J ver. 9.5.0
• PostgreSQL ver. 42.7.3
• Redis ver. 1.6

Switching between database roles and warehouses just got a lot faster, too. If you work in Snowflake, you no longer need to manually execute SET ROLE commands or dig through connection settings to change your permissions for the current session. A new dropdown menu in the query console toolbar lets you swap between available roles and warehouses instantly.

Working with data

We’ve made it possible to set grid cell values using SQL expressions instead of being limited to literal values. With the new SQL Expression mode in the data editor, you can enter any valid SQL expression into a cell, for example, NOW(), and DataGrip will use the result as the new cell value. When you submit the changes, the IDE incorporates your expression directly into the generated UPDATE or INSERT statement without escaping it as a string.

The new mode also allows you to enter values that begin with 0x in numeric columns. Now you can just turn the SQL Expression mode on and enter the value, instead of running SQL commands to update the cell.

Database explorer

The Database Explorer tool window now has a redesigned empty state that offers quick actions for data source creation, including those described in our quick start guide.

With the reworked database colors system, it is easier to assign a color to a data source, database object, or folder using a fresh and consistent UI. The behavior of custom colors has been significantly improved, making the shades suit both the light and dark IDE themes. Custom colors are now available for data source folders, too. For better discoverability, we’ve moved the database colors settings to the main IDE Settings dialog under Settings | Database | Database Explorer.

For database objects that have the same prefix, Database Explorer can now put them into individual groups. The group gets the prefix name. For example, my_table01 and my_table02 are grouped under my_, and their names are displayed as table01 and table02 within the group. Currently, the following characters are treated as prefix delimiters: _, -, and $.

If you want to delete data source folders that contain other folders or data sources, select the items, right-click them, and then select Drop. DataGrip will ask for confirmation and display the list of items to be deleted.

Explain Plan menu and actions

Following user feedback, we’ve brought back the raw format actions that were removed in the previous release. Now, to open an explain plan in raw format, click the Raw button on the left-hand toolbar of the Query Plan tab. It will open the Raw inner tab. If you’re already viewing the raw explain plan, this button says Show Tree and opens the Operations Tree inner tab. To add the raw format actions to the Explain Plan dropdown, go to Settings | Appearance & Behavior | Menus and Toolbars, select Explain Plan, and click Add.

Query files and consoles

Now, you can use variables to add more details to query console names in the editor tab headers. For example, you can add the attached data source, database, schema, or search path. To use them, go to Settings | Database | Query Files and Consoles. To add a variable to a console name, place the caret where you want to insert it in the Template field and click the corresponding variable button.

Code editor

In the code editor, you can now find the execution time right next to each query. After a query is executed, DataGrip displays its execution time on the first line of the query.

We’ve significantly expanded ClickHouse and Snowflake SQL support by including new syntax, improved syntax recognition, and support for additional statements and functions, such as ClickHouse query parameters and SYSTEM statements, and Snowflake flow operations, DATABASE ROLE syntax, and HASH functions.

If you’re interested in upgrading to DataGrip 2026.2, or if you have any questions or suggestions, here are a few links you might find useful:

• Download DataGrip 2026.2.
• Visit our What’s New page for the full list of improvements.
• Contact us on X.
• Report any bugs to our issue tracker

The DataGrip team

WebStorm 2026.2 is now available!

If you work on a large TypeScript codebase, this release is a meaningful upgrade. TypeScript 7 support ships out of the box for projects already using it, delivering faster type checking without requiring full project migration. GitHub Copilot is now natively integrated – with no separate plugin or additional setup needed. The new agent skills manager lets you give AI agents reusable knowledge about your stack, which they retain across projects and sessions.

This release also brings full React 19 support in React Buddy, and a set of top-voted quality fixes ships across the editor, Git tooling, settings, and more.

DOWNLOAD WEBSTORM 2026.2

The highlights of this release include:

TypeScript 7 support

• A rewritten compiler for faster performance in large TypeScript codebases, available without project migration

AI-powered development

• Native GitHub Copilot integration – Access the AI coding assistant from WebStorm’s AI chat with no plugin setup required
• Agent skills manager – Give your AI agents reusable stack knowledge for every session

Additional plugins

• Full React 19 support in React Buddy

This release also includes numerous fixes and quality-of-life improvements. See them below.
You can update to WebStorm 2026.2 via the Toolbox App or download it directly from our website.

TypeScript 7

Support for large codebases

If your TypeScript project has grown to the point where completions lag and refactorings feel sluggish, TypeScript 7 can help. Microsoft rewrote the compiler and language server in Go, bringing faster type checking, more responsive completions, and snappier refactorings, especially in large codebases where the old toolchain struggled most. In our testing on large real-world projects, WebStorm with TypeScript 7 loaded projects significantly faster than with the classic language server. For example, project load time on the Kibana codebase went from ~12 seconds to ~3 seconds, which means editor responsiveness improved roughly fourfold.

WebStorm 2026.2 supports TypeScript 7 as the default for projects already using it, with an opt-in upgrade path for those still on earlier versions. You get the full speed benefit immediately – no full project migration required.

If you’re working in a large TypeScript monorepo and project load or editor responsiveness is a daily friction point, this is the release you’ve been waiting for.

AI-powered development

Native GitHub Copilot integration

You can now use GitHub Copilot in WebStorm without any extra setup. Copilot is natively integrated and available directly from the AI chat’s agent picker – the result of a direct partnership between JetBrains and Microsoft. Like any other IDE-native feature, it’s stable, tested alongside the IDE, and avoids configuration drift.

Sign in with your GitHub account via OAuth, and Copilot is ready to use. No plugin setup or registry configuration is required.

Please note: You need a separate GitHub Copilot subscription to access the AI coding agent directly in WebStorm.

Agent skills manager

New in WebStorm 2026.2, agent skills give coding agents reusable knowledge about frameworks, conventions, and tooling. Instead of re-explaining the same setup in every new chat window, you can install a skill once and make that context available across projects and sessions.

With the new skills manager, you can browse and manage skills directly from the IDE, connect external registries such as public GitHub repositories, or import skills you’ve already configured for Claude Code or Codex.

Currently supported agents: Claude and Codex.

Framework and ecosystem updates

Frameworks

WebStorm now uses updated bundled language servers for Astro and Prisma. Angular workflows have been improved thanks to fixes for slow or missing TypeScript and Angular error updates, as well as more efficient dependency processing.

React Buddy is a WebStorm plugin (available on JetBrains Marketplace) that brings visual component tooling to your React workflow in the IDE: component palettes, interactive previews, and Storybook story creation. If you migrated to React 19 early, you probably noticed the plugin didn’t keep up. In 2026.2, React Buddy supports React 19.

Vue

Vue support has been updated with Vue language server 3.0 integration. This improves compatibility with the latest Vue tooling and fixes several reliability issues, including incorrect hover types, stack overflows during resolve, and plugin-loading problems in projects where related plugins such as Webpack or PostCSS are disabled.

Svelte

This release significantly enhances Svelte support. WebStorm now bundles an updated Svelte language server and TypeScript plugin, improves support for SvelteKit shared hooks and Svelte 5 named snippets, and fixes several parsing and highlighting issues around #await, inline expressions, comments, special characters, and CSS selectors used with <svelte:element>. Some of these improvements were also back-ported to the 2026.1.3 minor release.

CSS, Sass, SCSS, and Less

Style sheet support has been polished as well. Refactorings involving style sheet imports are safer, with fixes for SCSS and Sass glob imports and absolute CSS/SCSS import paths being rewritten unexpectedly. Color previews for modern CSS functions such as color() and color-mix() now work in Sass, SCSS, and Less files. The release also updates CSS syntax data and fixes a false positive around nested selectors.

Debugging, test runners, and Node.js

Debugging and run configurations are more predictable in WebStorm 2026.2. You can now disable source maps when debugging, Ctrl+Shift+Click correctly starts a debug session instead of only opening the browser, and JavaScript debugging handles error cases more reliably. Cypress and Playwright test execution is more stable, and Playwright no longer freezes in affected scenarios.

Node.js workflows have also been improved. WebStorm now better handles environment variables from login interactive shells for Node.js processes, detects Node.js runtimes in native Dev Containers, fixes empty project dependency data for Node.js projects, and avoids incorrectly skipping content roots named node_modules.

Performance and stability

This release also includes a range of performance and stability fixes. It addresses freezes in NPM run configuration checks, package.json completion, Tailwind language server startup, JSHint, and web-types processing. It also fixes typing, indexing, and first-code-analysis regressions, reduces excessive memory usage in JavaScript PSI handling, and improves search performance for JavaScript test frameworks.

User experience

Additionally, WebStorm 2026.2 brings notable UX improvements. Search Everywhere now preserves its scope between restarts, Markdown support includes footnotes and Mermaid diagrams out of the box, and you can customize double-key shortcuts in the keymap. The IDE now detects prunable Git worktrees and improves worktree support in WSL environments, bookmarks can be preserved when switching branches, and you can drag and drop a file into the terminal to insert its path.

Final words

This release focuses on where the IDE’s quality matters most for JavaScript and TypeScript developers – keeping type checking fast and responsive, connecting your preferred AI tools with less friction, and staying current with the ecosystem.

Try the latest version and let us know what you think. Your feedback shapes what comes next.