JetBrains/ideavim

This system is the IdeaVim plugin for JetBrains IDEs, providing a Vim emulation layer that integrates standard Vim editing commands, motions, and text objects with the IntelliJ platform. It features a modernized architecture with a Kotlin-based core, a new public API for third-party extensions, and support for split-mode remote development via RPC. The system also includes a comprehensive CI/CD pipeline for automated testing, release management, and plugin distribution.

119 changes.

This period focused on a massive architectural overhaul of IdeaVim, migrating the core codebase from Java to Kotlin and replacing the legacy action-group infrastructure with a modern, handler-centric design. The work involved removing hundreds of redundant wrapper classes, rewriting the Ex command line and key-mapping engines, and establishing a new extension system to support third-party plugins. Concurrently, the project significantly expanded its test coverage and CI infrastructure to validate the new architecture and ensure stability across various IDE versions.

69 changes.

This period focused on modernizing the plugin's architecture by introducing a new Kotlin-based API layer, migrating to Kotlin 2.0, and adopting immutable caret models for improved thread safety. The Vimscript engine was significantly expanded with comprehensive support for binary/unary operators, list manipulation, cursor functions, and dynamic function calls. Concurrently, the project established a robust testing infrastructure, including property-based and UI tests, while integrating popular extensions like vim-sneak and mini-ai.

38 changes.

This period focused on establishing the backend infrastructure for split-mode remote development, introducing RPC interfaces for file operations, navigation, and shell execution. Concurrently, the project expanded Vim compatibility by implementing autocmd support, various text object extensions, and popular plugins like Abolish and YankRing.

IdeaVim now includes the Abolish plugin, enabling case-aware text transformations. Users can define abbreviations that automatically adapt to surrounding casing (e.g., typing 'foo' becomes 'Foo' or 'FOO' depending on context) using the \:Abolish\ command. The plugin also provides the \:Subvert\ (aliased as \:S\) command for case-aware searching and substituting, as well as default \cr\ mappings for recasing words and operator-pending motions.

repository · high confidence

Users can now select entire class or method definitions using Vim text objects. The new \ac\ mapping selects a class definition (declaration and body), while \am\ and \aM\ select a method definition excluding or including JavaDoc/annotations respectively, and \im\ selects only the method body. This functionality is implemented via new extension modules (\classtextobj\, \functextobj\) and a language-agnostic PSI range finder that supports Java, Kotlin, Python, JavaScript, TypeScript, Go, Dart, PHP, Ruby, and Rust.

src/main/java/com/maddyhome/idea/vim/extension/classtextobj, src/main/java/com/maddyhome/idea/vim/extension/functextobj, src/main/java/com/maddyhome/idea/vim/extension/psi · high confidence

Introduces the YankRing extension, which records a history of yanks, deletes, and changes and allows users to cycle through previous yanked values using \<C-P\> and \<C-N\> to replace the last paste. This feature adds the :YRShow command to display the ring contents, :YRClear to reset the history, and :YRReplace to manually select entries. It also ensures that all standard paste commands (p, P, gp, gP, and bracket variants) are tracked so that cycling works correctly after any paste operation.

src/main/java/com/maddyhome/idea/vim/extension/yankring · high confidence

A new YouCompleteMe extension has been added that allows the Tab key to cycle through the IntelliJ code completion popup (selecting the next item with Tab and the previous with Shift-Tab) while the popup is open, mimicking the behavior of YouCompleteMe or SuperTab. When the completion popup is not active, Tab falls back to its standard indentation behavior, ensuring normal typing is not disrupted.

src/main/java/com/maddyhome/idea/vim/extension/youcompleteme · high confidence

Introduces a new autocmd subsystem that allows users to register commands triggered by Vim events such as FileType, BufRead, and BufWrite. The implementation supports augroups for organizing commands, file pattern matching for event filtering, and ensures that certain events (like InsertEnter) correctly switch the editor to normal mode before executing the command. It also includes a mapping layer to translate IntelliJ's internal file type names to standard Vim-style filetype strings (e.g., 'C++' to 'cpp') so that FileType autocmd patterns work as expected.

src/main/java/com/maddyhome/idea/vim/autocmd · high confidence

IdeaVim now includes a new 'highlightedyank' extension that visually highlights yanked text in the editor, ported from the popular vim-highlightedyank plugin. Users can customize the highlight duration (in milliseconds) and the background and foreground colors of the highlight using new variables. The highlight automatically clears when the user starts editing or when a new yank occurs, and it respects modal states to ensure correct behavior during dialogs.

src/main/java/com/maddyhome/idea/vim/extension/highlightedyank · high confidence

A new VCS root named 'IdeaVim Releases' has been added to the TeamCity configuration. It is configured to track the master branch of the JetBrains/ideavim repository using SSH authentication via an uploaded key, enabling specific version control tracking for release artifacts.

_.teamcity/\Self/vcsRoots · high confidence

Users can now use the has() function to check for supported features, including the newly added operating system type checks (e.g., win32, linux, mac, unix), and the pumvisible() function to detect whether the popup menu is currently visible during completion.

src/main/java/com/maddyhome/idea/vim/vimscript/model/functions/handlers · high confidence

Introduces the mini-ai extension, providing Vim motions aq, iq, ab, and ib for selecting text inside or around quotes and brackets. The extension implements a 'cover-or-next' selection logic: it prioritizes the smallest range covering the caret, falls back to the nearest following range, and finally to the nearest preceding range if no covering or following match is found. Inner motions (iq, ib) shrink the selection to exclude the delimiter characters.

src/main/java/com/maddyhome/idea/vim/extension/miniai · high confidence

A new Vim extension named 'vim-paragraph-motion' is introduced, enabling standard Vim paragraph navigation via the { and } keys. This feature registers mappings for normal, visual, and operator-pending modes, allowing users to move between paragraphs with the specified direction, respecting the current count (v:count1).

src/main/java/com/maddyhome/idea/vim/extension/paragraphmotion · high confidence

This change introduces the 'textobj-entire' extension, porting the vim-textobj-entire functionality to IdeaVim. It adds two new text objects: 'ae' selects the entire content of the current buffer, and 'ie' selects the buffer content excluding leading and trailing empty lines. These text objects are registered via the new VimInitApi text object registration API, with default mappings enabled unless the 'g:textobj\_entire\_no\_default\_mappings' variable is set.

src/main/java/com/maddyhome/idea/vim/extension/textobjentire · high confidence

This change introduces the Abolish extension, enabling users to convert text between various case styles (such as snake\_case, camelCase, PascalCase, kebab-case, and others) and substitute synonyms. The implementation adds the core logic for splitting words into atoms and rejoining them in different styles, as well as commands for searching and substituting variant words using Vim's search and substitute engines.

src/main/java/com/maddyhome/idea/vim/extension/abolish · high confidence

A new plugin descriptor file (IdeaVIM.ideavim-frontend-split.xml) has been added to register the frontend split-mode (Remote Dev) specific registrations. This module is configured to load only when the intellij.platform.frontend.split module is available, ensuring compatibility with IntelliJ's split frontend architecture.

src/main/resources · high confidence

A new internal action, AddInlineInlaysAction, has been introduced to the IdeaVim action package. This action allows users to trigger the display of inline inlays (specifically using the standard parameter hint renderer) at random intervals along the current visual line in the editor. This serves as a demonstration or testing mechanism for inline inlay rendering capabilities within the IDE integration.

src/main/java/com/maddyhome/idea/vim/action/internal · high confidence

A new status bar widget has been introduced to visually indicate when macro recording is active. When recording starts, the widget displays the target register (e.g., 'recording @a'), and it clears when recording finishes. A tooltip provides additional context ('No macro recording in progress') when the widget is empty. This feature is controlled by the global \showmode\ option and integrates with the existing Vim plugin infrastructure to update across all open projects.

src/main/java/com/maddyhome/idea/vim/ui/widgets/macro · high confidence

The Vim plugin now includes the textobj-line extension, which adds two new text objects: 'al' selects all characters in the current line (excluding the newline), and 'il' selects only the non-whitespace content of the current line. These text objects allow users to easily select entire lines or their meaningful content using standard Vim text-object syntax.

src/main/java/com/maddyhome/idea/vim/extension/textobjline · high confidence

This update introduces new commands for managing and navigating file marks. Users can now place the next available lowercase mark at the current cursor position using 'm', remove the mark on the current line with 'm-', and clear all buffer marks with 'm\<Space\>'. Additionally, navigation commands '\]' and '\[' now jump to marks in alphabetical order (falling back to positional order if the cursor is not on a marked line), while '\\]' and '\\[' continue to jump to the next or previous line containing any mark.

src/main/java/com/maddyhome/idea/vim/extension/signature · high confidence

This change introduces the initial resource bundle for the shared IdeaVim module, establishing the foundational assets required for the plugin to function across all product modes. It registers the core application services (CoroutineScopeProvider and SystemInfoService) in the plugin descriptor, ensuring they are available to both frontend and backend components. Additionally, it adds the plugin's SVG icons (including light, dark, disabled, and outline variants), a dictionary of Vim keywords and commands for IDE integration, and placeholder JSON files for KSP-generated extensions and commands, setting the stage for subsequent feature implementations.

ideavim-common/src/main/resources · high confidence

The Vim engine now supports the \line()\ and \col()\ functions, allowing users to retrieve the current line and column numbers of the cursor or specific marks. This new handler resolves cursor position queries for variables like the current caret, visual selection ends, marks, and special positions like the last line or column, enabling scripts that rely on these standard Vim functions to work correctly.

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/model/functions/handlers/cursorFunctions · high confidence

The sneak plugin, previously an external extension, is now included directly in IdeaVim. This brings native support for the 's' and 'S' keys to jump to two-character sequences in Normal mode, and 'z'/'Z' for operator-pending and visual mode jumps, matching the behavior of the original vim-sneak plugin. The integration also includes mappings for ';' and ',' to repeat the last sneak action, ensuring compatibility with existing vim-sneak workflows.

src/main/java/com/maddyhome/idea/vim/extension/sneak · high confidence

A new IntellijFunctionProvider has been added to the Vimscript function model, which registers the 'frontend\_vimscript\_functions.json' file as the source for IntelliJ-specific Vimscript functions. This change enables the IDE to load and execute custom Vimscript functions defined in the frontend configuration.

src/main/java/com/maddyhome/idea/vim/vimscript/model/functions · high confidence

The IdeaVim plugin now exposes an experimental public API (VimApi) that allows external plugins to interact with Vim features through a structured, scope-based DSL. This API provides access to modes, variables, commands, mappings, and text objects, with specific scopes (e.g., CommandScope, VariableScope) enabling type-safe registration and configuration. A separate VimInitApi is available during plugin initialization to ensure type safety for registration-only operations before the editor context is ready. The API is marked as experimental and requires explicit opt-in via the @VimPlugin annotation for plugin identification. Key features include suspendable functions for runtime operations (normal mode execution, editor access) and lambda-based scopes for configuration.

api/src/main/kotlin/com/intellij/vim/api · high confidence

The \api/src/main/kotlin/com/intellij/vim/api/models\ package now contains the foundational data models for the Vim API, including \Range\ (with \Simple\ and \Block\ variants using normalized start/end offsets), \Mode\ (enumerating all Vim editor modes and their selection types), \TextType\, \Color\, \Line\, \CaretInfo\, \CaretId\, \Jump\, \Mark\, \Path\, and \HighlightId\. These models define the structure for representing text selections, editor modes, colors, and navigation points within the API.

api/src/main/kotlin/com/intellij/vim/api/models · high confidence

This change introduces a set of new Remote Procedure Call (RPC) interfaces and data structures in the \ideavim-common\ module to support split-mode (Remote Development) scenarios. These additions include \BookmarkRemoteApi\ for IDE bookmark synchronization, \ChangeRemoteApi\ for backend undo grouping, \CommentaryRemoteApi\ for remote commenting, \FileRemoteApi\ for file operations, \FormatRemoteApi\ for code formatting, \JumpRemoteApi\ and \JumpRemoteTopic\ for navigation history, and \ProcessRemoteApi\ for shell command execution. Additionally, it adds \CoroutineScopeProvider\ for managing coroutine lifecycles and \IjVimSystemInfoService\ for platform information, ensuring that Vim commands requiring backend-only resources (like VFS, PSI, or the UndoManager) are correctly forwarded from the thin-client frontend to the backend IDE process.

ideavim-common/src/main/java · high confidence

The TeamCity project now includes dedicated build types for compatibility checks against external plugins, long-running and property-based tests, NeoVim integration tests, split-mode tests, and automated publishing of Dev, EAP, and major/minor/patch releases. These configurations standardize the CI pipeline by extracting verification, testing, and release logic into distinct, scheduled, or VCS-triggered jobs, ensuring that IdeaVim is validated against a broader set of plugins and test scenarios before distribution.

_.teamcity/\Self/buildTypes · high confidence

The project now includes a new TeamCity DSL configuration (\.teamcity/\_Self\) that defines the build infrastructure for IdeaVim. This configuration introduces a centralized \Constants.kt\ file to manage version strings for release channels (default, EAP, dev) and specific test suites (Nvim, property-based, long-running), all currently pinned to version 2025.3. The \Project.kt\ file establishes the main project structure, registering sub-projects for releases and VCS roots, and defining a suite of active build types including compatibility checks, long-running tests, property-based tests, split-mode tests, and Nvim integration tests. Notably, the configuration specifies that the Latest EAP and 2026.2 builds must run on Java 25 due to bytecode compatibility requirements, while other versions use Java 21. It also configures a shared Gradle build cache and disables Java OOM detection for builds.

_.teamcity/\Self · high confidence

This change introduces several new UI elements for IdeaVim. It adds a Tutor feature providing an interactive tutorial for new users. A new status bar widget displays the current partial Vim command (showcmd) and updates based on global options. The Output panel now supports closing via mouse click when specific mouse options are enabled. Additionally, visual styling for the Ex and Output panels has been improved with a custom border, and internal refactoring ensures proper repositioning of tool windows.

src/main/java/com/maddyhome/idea/vim/ui · high confidence

A new VimEverywhere extension is introduced, providing visual keyboard shortcuts (hints) for navigating UI components and a dedicated tool-window navigation mode. The hints feature adds a ToggleHintsAction that overlays clickable labels on interface elements, allowing users to activate actions by typing displayed characters, with a custom RoundedHintLabel for rendering. Additionally, a ToolWindowNavDispatcher enables navigating between tool windows using standard Vim keybindings (e.g., Ctrl+W followed by h/j/k/l or arrow keys), integrating with the existing WindowGroup navigation logic.

src/main/java/com/maddyhome/idea/vim/extension/hints · high confidence

A new Executor class has been introduced in the vimscript package to handle VimScript execution. This component implements the VimScriptExecutorBase interface and specifically adds logic to ensure that files are saved before they are processed. It achieves this by checking if a file's associated document is unsaved and, if so, saving it immediately using the IntelliJ Platform's FileDocumentManager and VirtualFileManager, thereby preventing data loss during script execution.

src/main/java/com/maddyhome/idea/vim/vimscript · high confidence

A new VimWidgetListener class has been added to the UI widgets package to handle updates to Vim-related UI components. This listener implements GlobalOptionChangeListener and VimPluginListener, ensuring that the widget is refreshed whenever global Vim options change or when the Vim plugin is enabled or disabled.

src/main/java/com/maddyhome/idea/vim/ui/widgets · high confidence

This update adds several new Vimscript functions to the IdeaVim engine, allowing users to inspect, list, and programmatically modify key mappings and digraphs. The new \maparg()\, \mapcheck()\, \maplist()\, and \mapset()\ functions enable querying specific mapping details, checking if a mapping exists, listing all current mappings, and restoring mappings from a dictionary respectively. Additionally, \hasmapto()\ allows checking if a specific key sequence is mapped. Support for digraphs is expanded with \digraph\_get()\, \digraph\_getlist()\, \digraph\_set()\, and \digraph\_setlist()\, enabling retrieval and modification of custom digraph definitions. These functions operate within the \mappingFunctions\ handler package and rely on the underlying key and digraph injectors to interact with the editor's state.

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/model/functions/handlers/mappingFunctions · high confidence

Added support for the histadd(), histdel(), histget(), and histnr() Vimscript functions, allowing users to programmatically add, delete, retrieve, and query entries in command-line and search history within the editor.

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/model/functions/handlers/historyFunctions · high confidence

The Vim engine now supports several new Vimscript functions for working with lists: \add()\ appends an item to a list, \insert()\ places an item at a specific index, \index()\ finds the position of an item, \indexof()\ finds indices matching a pattern or function, \flatten()\ and \flattennew()\ reduce nested lists, \join()\ concatenates list items into a string, \range()\ generates a sequence of numbers, \sort()\ orders list elements with various comparison modes, \uniq()\ removes adjacent duplicates, and \split()\ divides a string into a list. These handlers are implemented in the \listFunctions\ package and integrate with the existing \BuiltinFunctionHandler\ base class.

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/model/functions/handlers/listFunctions · high confidence

The file group now exposes a new remote procedure call (RPC) interface for managing files, enabling the frontend to handle file operations asynchronously. This includes capabilities to open, close, and switch between files (including selecting the last or next file), retrieve buffer names and file info, and perform file name completion with path resolution (supporting absolute, home, and relative paths). The implementation registers a dedicated RPC provider and helper to resolve file paths for command-line completion, shifting file management logic from the core plugin to this new backend service layer.

ideavim-backend/src/main/java/com/maddyhome/idea/vim/group/file · high confidence

This change introduces several new modules and plugin descriptors to support cross-IDE compatibility and backend communication. The \ideavim-backend\ module adds utility functions for file resolution, an RPC provider for commentary (line/block comments) that ensures correct behavior in Rider and CLion Nova, and a listener that bridges IntelliJ's recent places to Vim's change list for accurate \g;\ navigation. Additionally, new plugin descriptors and provider implementations are added for \ideavim-rider\ (Rider), \ideavim-clion-nova\ (CLion Nova), \ideavim-acejump\ (AceJump integration), and \ideavim-terminal\ (terminal editor disabler), ensuring IdeaVim correctly identifies and adapts to these specific IDE environments.

(repo-wide) · high confidence

Users can now edit registers and macros containing control characters (like \<CR\> or \<ESC\>) via a dedicated editor that displays them in printable caret notation (e.g., ^M), solving the issue where IntelliJ Documents cannot store raw control bytes. Additionally, insert-mode navigation keys (Up, Down) and Tab now explicitly manage undo sequences to prevent incorrect undo behavior, and the Tab key is handled to allow IDE-specific actions (like LLM suggestions) to take precedence over Vim's default tab insertion when appropriate.

src/main/java/com/maddyhome/idea/vim/action/editor · high confidence

A new mode widget has been added to the status bar, replacing the previous experimental \showmodewidget\ option. This widget displays the current Vim mode (Normal, Insert, Replace, Visual, etc.) and supports two built-in themes—'Term' and 'Dracula'—as well as full manual color customization for each mode and selection type. Users can configure the widget's appearance via a dedicated settings popup or by setting global variables (e.g., \g:widget\_mode\_theme\) in their \.ideavimrc\. The widget also persists its state across sessions and handles edge cases where the status bar is not yet initialized.

src/main/java/com/maddyhome/idea/vim/ui/widgets/mode · high confidence

IdeaVim introduces a new extension system that allows plugins to register via the \IdeaVIM.vimExtension\ extension point. Extensions are now managed through \VimExtensionRegistrar\, which registers them as global toggle options (e.g., \:set nerdreetree\) and handles their lifecycle. A new \VimExtension\ interface defines the extension contract, including a new \init(VimInitApi)\ method that provides a safe, init-time API for registering mappings and commands before editor context is available. The \ShortcutDispatcher\ class is now available to help extensions handle key bindings using a trie-based approach.

src/main/java/com/maddyhome/idea/vim/extension · high confidence

IdeaVim introduces a new extension loading and management system in the thin API layer. This includes a new JSON-based configuration provider that uses file locking to ensure exclusive access when reading or writing extension lists, preventing data corruption. A new plugin listener ensures that IdeaVim-specific extensions are properly disabled and cleaned up before the plugin is unloaded, and automatically enables extensions marked in the configuration. Additionally, a new highlighting service maps Vim highlight IDs to IntelliJ editor highlighters, and a new plugin service exposes core Vim operations like normal-mode execution and operator function export.

src/main/java/com/maddyhome/idea/vim/thinapi · high confidence

IdeaVim now includes an experimental inspection for .ideavimrc and \_ideavimrc files that detects when extensions are defined using the old syntax and suggests replacing them with the \Plug\ syntax. The inspection provides a quick-fix that automatically rewrites the configuration line to use the correct \Plug 'alias'\ format, helping users migrate to the modern extension definition method.

src/main/java/com/maddyhome/idea/vim/inspections · high confidence

The IdeaVim API has been reorganized into a set of dedicated scopes (CommandScope, DigraphScope, ListenersScope, MappingScope, ModalInput, OptionScope, OutputPanelScope, StorageScope, TabScope, TextObjectScope, TextScope, VariableScope) to provide structured, type-safe access to Vim features. Plugin authors can now use DSL-style accessors (e.g., \api.commands { ... }\) to register custom commands and operators, manage key mappings across specific modes (normal, visual, select, operator-pending), handle modal input dialogs, read and write Vim options and variables with type safety, store keyed data in windows/buffers/tabs, manage tabs, register custom text objects, and listen to editor events like mode changes and yanks. This modularization replaces the previous flat API structure, offering clearer separation of concerns and improved ergonomics for plugin authors.

api/src/main/kotlin/com/intellij/vim/api/scopes · high confidence

New users of IdeaVim in GoLand now see an editor notification warning them that they are using the plugin, with options to disable it or dismiss the message. The notification automatically disappears after a set number of Vim commands or if the user explicitly disables the plugin. Additionally, a new Troubleshooter service has been introduced to detect configuration issues, such as mappings containing \:action\ calls.

src/main/java/com/maddyhome/idea/vim/troubleshooting · high confidence

Added a set of Kotlin scripts in the release tooling to automate version management and Git operations. These include \calculateNewDevVersion.kt\ and \calculateNewEapVersion.kt\ to compute next development and EAP versions based on commit history, \calculateNewVersion.kt\ for major/minor/patch releases, \addReleaseTag.kt\ to create Git tags, and \selectBranch.kt\ to handle branch checkout and creation. Utility functions in \util.kt\ support these tasks by parsing semantic versions and interacting with the Git repository via JGit.

scripts/src/main/kotlin/scripts/release · high confidence

IdeaVim now collects detailed usage metrics to help improve the plugin. This includes tracking which Vim actions and copied actions are used (ActionTracker), reporting the state of IntelliJ-specific options like ideajoin and ideamarks (OptionsState), monitoring shortcut conflicts across normal, insert, and visual modes (ShortcutConflictState), and gathering data on Vimscript usage such as sourced files, .ideavimrc size, and enabled extensions (VimscriptState). It also reports on the Mode Widget's visibility and theme settings (WidgetState) and general plugin state including enabled extensions (PluginState).

src/main/java/com/maddyhome/idea/vim/statistic · high confidence

The repository has been initialized with essential project configuration files, including an .editorconfig to enforce consistent code style (2-space indentation for Java and Kotlin) and a .gitignore to exclude build artifacts and local settings. Documentation and metadata are now present in AUTHORS.md, CHANGES.md (adhering to Keep a Changelog and Semantic Versioning), and README.md, providing a structured history and contributor list for the IdeaVim plugin.

(repo-wide) · high confidence

The Vim engine now implements the \call()\, \function()\, and \funcref()\ built-in functions, allowing users to invoke functions dynamically via references and pass arguments as lists. The \call()\ function executes a function reference with a list of arguments and an optional dictionary context, while \function()\ and \funcref()\ convert function names into callable references, supporting scope resolution and partial application via optional dictionary arguments.

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/model/functions/handlers/varFunctions · high confidence

Added support for the vim-textobj-user plugin framework, allowing users to declaratively define custom text objects via the \textobj\#user\#plugin\ and \textobj\#user\#map\ functions. This extension registers the necessary VimScript function handlers to interpret plugin specifications and map keys to the resulting \\<Plug\>\ interfaces, enabling compatibility with plugins that rely on this standard for defining flexible text selection ranges.

src/main/java/com/maddyhome/idea/vim/extension/textobjuser · high confidence

Added support for standard Vim window-resizing keybindings in normal mode. Users can now adjust the current window's height using Ctrl-W + and Ctrl-W -, set a specific height with Ctrl-W \_, and modify the window's width using Ctrl-W \>, Ctrl-W \<, and Ctrl-W \|. Additionally, Ctrl-W = is supported to equalize the proportions of all open windows.

src/main/java/com/maddyhome/idea/vim/resize · high confidence

The VimscriptParser object now exposes a \registerCommandProvider\ function, allowing external modules to dynamically register additional \ExCommandProvider\ implementations at runtime. This enables lazy loading and extensibility of ex commands without requiring static initialization of all command classes, improving startup performance and modularity for plugins that add custom Vim commands.

src/main/java/com/maddyhome/idea/vim/vimscript/parser · high confidence

The core IdeaVim Vim-emulation plugin files have been deleted from the source tree. This includes the main plugin entry point (VimPlugin.java), the central keystroke dispatcher (KeyHandler.java), the typed-action interceptor (VimTypedActionHandler.java), and specific mode handlers such as VisualExitModeHandler.java. As a result, the Vim emulation capability provided by this plugin is no longer present in this codebase.

src/com/maddyhome/idea/vim · high confidence

The dedicated handler classes \FileSaveHandler\ and \FileSaveCloseHandler\ in the \src/com/maddyhome/idea/vim/handler/file\ package have been removed. This eliminates the specific code paths that previously invoked \CommandGroups.getInstance().getFile().saveFiles()\ and \CommandGroups.getInstance().getFile().closeFile()\ for these operations, indicating a shift in how file saving and closing actions are processed within the plugin.

src/com/maddyhome/idea/vim/handler/file · high confidence

The legacy Ex command processing classes in the \src/com/maddyhome/idea/vim/ex\ package have been removed. This includes the core \CommandHandler\ abstract class, the \CommandParser\ singleton, and supporting data structures like \CommandName\, \CommandNode\, \ExCommand\, and \Ranges\. This cleanup eliminates the old Java-based command registration and parsing mechanism, which is being replaced by a new architecture (likely Kotlin-based extension points) to support modern features like multiple carets and dynamic command handling.

src/com/maddyhome/idea/vim/ex · high confidence

The specific delete handler classes in the \src/com/maddyhome/idea/vim/handler/change/delete\ package (including \DeleteCharacterHandler\, \DeleteLineHandler\, \DeleteVisualHandler\, and others) have been removed. These files previously acted as thin wrappers delegating delete operations to the \CommandGroups\ change group; their removal indicates a refactoring of the delete command execution path, likely consolidating or replacing these individual handler implementations.

src/com/maddyhome/idea/vim/handler/change/delete, src/com/maddyhome/idea/vim/handler/key, src/com/maddyhome/idea/vim/handler/motion · high confidence

The custom Ex command-line interface implementation has been removed from the plugin. This change deletes the \ClipboardHandler\, \CommandEntryPanel\, \ExDocument\, \ExEditorKit\, \ExKeyBindings\, and \ExTextField\ classes, which previously provided the standalone glass-pane overlay, custom document model for insert/overwrite modes, and specific key bindings for the Vim ex command entry.

src/com/maddyhome/idea/vim/ui · high confidence

The legacy \Mark\ and \Register\ classes in the common package have been removed. These classes previously handled file mark storage (line/column/file references) and basic register text storage, respectively. Their removal indicates a refactoring of how IdeaVim manages buffer marks and clipboard/yank registers, likely replacing them with more robust or integrated implementations elsewhere in the plugin.

src/com/maddyhome/idea/vim/common · high confidence

The \src/com/maddyhome/idea/vim/action/key\ directory has been removed, deleting all individual key-action classes (such as BackSpaceAction, DeleteAction, EscapeAction, and KeyAction) that previously extended \EditorAction\ or \AnAction\. This cleanup eliminates the old per-key action infrastructure, aligning with the switch to registering custom shortcut sets for Vim-enabled editors.

src/com/maddyhome/idea/vim/action/key · high confidence

The \AbstractCommandAction\, \ExEntryAction\, and \ResetModeAction\ classes have been removed from the codebase. These files, which previously served as wrappers for Vim command execution and mode resetting, are no longer present, indicating a shift in how these operations are handled internally.

src/com/maddyhome/idea/vim/action · high confidence

The specific action classes for copy and paste operations (PutTextAfterCursorAction, PutTextBeforeCursorAction, PutVisualTextAction, SelectRegisterAction, YankLineAction, YankMotionAction, YankVisualAction, and YankVisualLinesAction) have been removed from the codebase. These classes previously extended IntelliJ's EditorAction or AbstractCommandAction to handle Vim yank and put commands; their removal indicates a shift in how these operations are registered and executed, likely relying on a new handler-based or plugin.xml-defined mapping system instead.

src/com/maddyhome/idea/vim/action/copy · high confidence

The custom undo subsystem in the \src/com/maddyhome/idea/vim/undo\ package has been removed. This change deletes the \DocumentChange\, \EditorUndoList\, \UndoCommand\, and \UndoManager\ classes, which previously managed undo/redo history via custom document listeners and command objects. This cleanup eliminates redundant internal state management in favor of the platform's native undo handling.

src/com/maddyhome/idea/vim/undo · high confidence

The insert-mode action handlers in the \src/com/maddyhome/idea/vim/handler/change/insert\ package have been removed. This includes specific handlers for commands such as \InsertAfterCursor\, \InsertBeforeCursor\, \InsertEnter\, \InsertExitMode\, and \InsertPreviousInsert\, among others. These classes previously delegated insert-mode operations to the \CommandGroups\ change group; their removal indicates a structural change to how insert-mode actions are processed within the plugin.

src/com/maddyhome/idea/vim/handler/change/insert · high confidence

The Java implementation files for Vim ex command handlers (including Copy, Delete, Edit, Find, GotoCharacter, Help, JoinLines, Mark, MoveText, NextFile, PreviousFile, PutLines, Quit, SelectFile, ShiftLeft, ShiftRight, Substitute, Write, and Yank) have been deleted from the src/com/maddyhome/idea/vim/ex/handler directory. This removal indicates that the logic for these commands is no longer maintained in these specific Java handler classes, likely having been migrated to Kotlin or refactored into other components of the plugin.

src/com/maddyhome/idea/vim/ex/handler · high confidence

A new \newapi\ package has been added to provide a dedicated Kotlin API layer for IntelliJ platform integration. This includes concrete implementations for core Vim abstractions such as \IjVimEditor\, \IjVimCaret\, and \IjVimSearchGroup\, alongside supporting infrastructure like \IjVimApplication\ for threading and \IjNativeActionManager\ for mapping Vim commands to IDE actions. The change also introduces factory classes (\VimEditorFactory\) and legacy state loaders to facilitate the migration of existing functionality to this new architecture.

src/main/java/com/maddyhome/idea/vim/newapi · high confidence

The internal \src/com/maddyhome/idea/vim/group\ package has been removed, eliminating the legacy singleton-based command group structure (including \CommandGroups\, \MotionGroup\, \ChangeGroup\, \CopyGroup\, \MarkGroup\, \RegisterGroup\, \FileGroup\, and \MacroGroup\) and its associated base classes (\ActionGroup\, \AbstractActionGroup\). This change removes the previous mechanism for managing Vim key mappings and editor state, indicating a shift to a new internal architecture for handling Vim commands and editor interactions.

src/com/maddyhome/idea/vim/group · high confidence

The specific action wrapper classes in the change/change package (such as ChangeCaseLowerMotionAction, ChangeCharacterAction, and ChangeVisualAction) have been removed. These classes previously extended IntelliJ's EditorAction and delegated to specific handlers; their removal indicates a shift in the plugin's architecture where these commands are now handled directly by their corresponding handlers or a unified command action system, simplifying the action registration and execution flow for users.

src/com/maddyhome/idea/vim/action/change/change · high confidence

The internal key-mapping engine in the \src/com/maddyhome/idea/vim/key\ package has been converted from Java to Kotlin. This change removes the legacy Java implementation classes (such as \KeyParser\, \CommandNode\, and \RegisterActions\) that previously handled the parsing of Vim keystrokes and the registration of action mappings. For users, this represents a structural improvement to the plugin's core input handling, laying the groundwork for the new command node architecture described in other changelog entries, without altering the external Vim keybindings or commands.

src/com/maddyhome/idea/vim/key · high confidence

The annotation-processor module now uses Kotlin Symbol Processing (KSP) to generate JSON configuration files for Vim commands, motions, and extensions. New annotations—@ExCommand, @CommandOrMotion, @VimscriptFunction, and @VimPlugin—are processed by dedicated SymbolProcessors (ExCommandProcessor, CommandOrMotionProcessor, VimscriptFunctionProcessor, ExtensionsProcessor) to produce sorted JSON mappings (e.g., ex\_commands\_file, commands\_file, vimscript\_functions\_file, extensions\_file) written to a generated directory. This replaces previous YAML-based command registration with a compile-time, annotation-driven approach, enabling lazy loading and consistent JSON formatting for command tables and extension providers.

annotation-processors · high confidence

IdeaVim now automatically detects and migrates legacy Vim configuration files (versions 3–6) to the new version 7 format. This process separates settings into local and shared components, ensuring that user preferences are correctly preserved and structured when upgrading from older IdeaVim versions.

src/main/java/com/maddyhome/idea/vim/config · high confidence

A new backend RPC handler has been added to support remote auto-indent formatting. The implementation processes multiple line ranges from bottom to top to prevent line-number shifting, groups all document modifications into a single undo step via CommandProcessor, and ensures the system selection is not updated during the indent operation. A provider registers this handler for the platform's remote API extension point.

ideavim-backend/src/main/java/com/maddyhome/idea/vim/group/format · high confidence

The backend module now includes the core components to support synchronized navigation jumps in split or remote modes. A new RPC handler (JumpRemoteApiImpl) delegates navigation recording to the platform's document history, while a provider registers this handler for remote calls. Additionally, a listener captures IDE navigation events (recent place additions/removals) and broadcasts them to the frontend, ensuring that jump history is kept in sync across the IDE interface.

ideavim-backend/src/main/java/com/maddyhome/idea/vim/group/jump · high confidence

The backend now implements the ProcessRemoteApi to handle shell command execution for remote clients. This change ensures that after a shell command completes, the Virtual File System (VFS) is refreshed so that any file changes made by the command are immediately visible in the editor. Additionally, standard input is properly closed with an EOF signal after writing, preventing external commands that read from stdin (such as \sort\) from blocking indefinitely.

ideavim-backend/src/main/java/com/maddyhome/idea/vim/group/process · high confidence

The bookmark RPC implementation has been extracted from the main backend module into a new \ideavim-backend-bookmarks\ module. This change allows the plugin to support IDE versions where the \intellij.platform.bookmarks\ module is available (2026.2+) as well as earlier versions where bookmark classes are part of the platform core, ensuring bookmark functionality works across different IDE versions without breaking other RPC features if the bookmarks module is absent.

ideavim-backend-bookmarks · high confidence

A new properties file, IdeaVimBundle.properties, has been introduced to centralize user-facing strings for the plugin. This file now contains the text for the Vim mode widget settings (including theme selection and color customization fields), configuration options for the .ideavimrc path and key repeat behavior, action descriptions (such as tracking action IDs and editing control characters), and error messages for extensions like argtextobj and NERDTree. This change consolidates these UI labels and messages into a single location for easier management.

src/main/resources/messages · high confidence

The IdeaVim plugin now uses a centralized \VimIcons\ class to manage its user interface icons. This change introduces a new Java class that loads SVG icons (such as the main IdeaVim logo, disabled state, Twitter, and YouTrack) via IntelliJ's \IconManager\, replacing any previous ad-hoc or hardcoded icon references with a standardized, reusable loading mechanism.

src/main/java/com/maddyhome/idea/vim/icons · high confidence

The \CommandState\ class in the command package has been refactored to act as a compatibility shim for external plugins, delegating its state queries to the new \VimStateMachine\. All public members, including mode access, command building, and mapping state, are now marked as deprecated with scheduled removal notices, directing users to access state via \injector.vimState\ or \KeyHandler.keyHandlerState\ instead. This change ensures backward compatibility while encouraging migration to the new state management architecture.

src/main/java/com/maddyhome/idea/vim/command · high confidence

Users can now explicitly configure the path to their .vimrc file via the new IjVimrcPathService, which supports IDE path macros (e.g., $USER\_HOME$) for flexible location resolution. Additionally, Vim variables are now persisted to the local application configuration (vim\_settings\_local.xml), ensuring that global variable settings survive IDE restarts.

src/main/java/com/maddyhome/idea/vim/vimscript/services · high confidence

The individual action classes in the delete package (such as DeleteCharacterAction, DeleteLineAction, and DeleteVisualAction) have been removed. These classes previously extended IntelliJ's EditorAction and simply instantiated their corresponding handlers. This change indicates a shift in how delete operations are registered and executed, likely moving towards a handler-centric or plugin.xml-defined mapping approach, though the specific new mechanism is defined in other parts of the codebase.

src/com/maddyhome/idea/vim/action/change/delete · medium confidence

The helper utilities in src/main/java/com/maddyhome/idea/vim/helper have been converted from Java to Kotlin. This migration includes new or refactored classes for managing caret visual attributes, extracting key strokes from action events, handling command-line window keys, and executing IDE actions, alongside updated editor and inlay helpers to support the new codebase structure.

src/main/java/com/maddyhome/idea/vim/helper · high confidence

The dot-repeat (.) command now groups repeated changes into a single undo step, meaning a single \u\ will revert the entire repeated sequence rather than individual insertions or deletions. Additionally, the \g@\ operator is now available in Normal and Visual modes, allowing users to apply custom functions defined via the \operatorfunc\ option to text ranges selected by motions or visual selections.

src/main/java/com/maddyhome/idea/vim/action/change · high confidence

The paste operation now suggests enabling the control characters editor when pasted text contains control characters, enhancing visibility of special characters. Additionally, the \ideaput\ command's smart insert functionality is preserved by temporarily placing text in the clipboard, ensuring IDE-specific processing (like import insertion) works correctly while maintaining proper clipboard state management.

src/main/java/com/maddyhome/idea/vim/group/copy · high confidence

The plugin now better aligns the IntelliJ editor's selection state with Vim modes when performing refactorings. A new helper ensures that selections are correctly removed or adjusted when entering modes that do not support them, and it handles edge cases during inline renaming by moving the caret to the start of a variable range when in 'idearefactormode\_keep'. This prevents visual glitches and ensures the editor state remains consistent with Vim's internal mode logic during complex IDE interactions.

src/main/java/com/maddyhome/idea/vim/vimscript/model/options · high confidence

Remote Vim commands that modify the document are now grouped into a single undo step. This is achieved by a new backend implementation that wraps document changes in the IDE's command processor, ensuring that a sequence of edits triggered remotely is treated as one atomic action for the user's undo history.

ideavim-backend/src/main/java/com/maddyhome/idea/vim/group/change · high confidence

IdeaVim now uses a 100ms delay to handle visual selection changes, preventing the plugin from reacting to temporary selections made by the IDE (such as auto-indentation or template navigation). This ensures that modes remain stable during rapid editor actions, and the 'idearefactormode' option now correctly preserves your current selection mode when navigating through live templates.

src/main/java/com/maddyhome/idea/vim/group/visual · high confidence

The plugin now loads frontend ex commands from a JSON file (frontend\_ex\_commands.json) via the new IntellijExCommandProvider, replacing the previous YAML-based approach and enabling lazy classloading of ex command definitions.

src/main/java/com/maddyhome/idea/vim/vimscript/model/commands · high confidence

The \scripts-ts\ directory now contains the TypeScript implementations for several internal automation tools, including the 'What's New' site builder, changelog promoter, EAP release actions, YouTrack ticket analysis completion, property test failure collector, and plugin dependency checker. These scripts replace their previous counterparts to provide a unified, type-safe codebase for release and maintenance workflows.

scripts-ts · high confidence

The vim-engine has been upgraded to Kotlin 2.0, bringing improved language features and compiler optimizations. Concurrently, the engine now utilizes an immutable caret model, which changes how caret state is managed and passed through the system to improve thread safety and consistency. This architectural shift requires updates to how caret positions are accessed and modified, ensuring that visual and selection states are handled more robustly across different editing modes.

vim-engine · high confidence

The NERDTree extension now provides more reliable navigation and key handling in the project tree. Pressing \<ESC\> during key sequences (such as SpeedSearch) now correctly clears the buffer and restores the previous selection, preventing the tree from getting stuck or losing focus. Navigation keys like 'j', 'k', 'G', and 'gg' are delegated to the underlying Swing tree actions, ensuring consistent behavior with native IDE shortcuts. Additionally, the dispatcher runs on a background thread to improve responsiveness, and invalid key sequences no longer cause errors but instead show a clear indication to the user.

src/main/java/com/maddyhome/idea/vim/extension/nerdtree · high confidence

A new TeamCity subproject named 'IdeaVim releases' has been introduced to manage stable and EAP release workflows. This subproject groups together specific build configurations for major, minor, patch, EAP, and dev releases, and configures the necessary hidden credentials (certificate chain, private key, and password) required for the signing and publishing process.

_.teamcity/\Self/subprojects · high confidence

A new abstract class IdeActionHandler has been introduced to serve as the base for Vim commands that map to existing IDE actions. This class implements the execution logic by delegating to the action executor and ensuring the caret is scrolled into view, providing a standardized foundation for handlers in this package.

src/main/java/com/maddyhome/idea/vim/handler · high confidence

The IDE detection logic for CLion Nova and Rider has been refactored to use the plugin model v2 extension points. Instead of hardcoded checks, the plugin now registers and queries \ClionNovaProvider\ and \RiderProvider\ interfaces via extension points, allowing external plugins to dynamically declare support for these specific IDEs and typing engines.

src/main/java/com/maddyhome/idea/vim/ide · high confidence

The Ex command-line UI has been rebuilt in Kotlin to support advanced features including a live 'inccommand' preview for substitute commands, a paginated completion panel for wildmenu suggestions, and proper rendering of non-printable characters. The new implementation introduces a custom styled document and editor kit to handle insert/overwrite modes, input method composition highlights on macOS, and modeless selection, while also fixing focus race conditions and memory leaks associated with the previous Swing-based components.

src/main/java/com/maddyhome/idea/vim/ui/ex · high confidence

The \RedoAction\, \UndoAction\, and \RepeatChangeAction\ classes in the \src/com/maddyhome/idea/vim/action/change\ package have been deleted. These classes previously served as thin wrappers extending IntelliJ's \EditorAction\ to delegate to their respective handlers (\RedoHandler\, \UndoHandler\, \RepeatChangeHandler\). Their removal indicates a shift in how these Vim commands are integrated into the editor, likely moving away from the \EditorAction\ inheritance model toward direct handler usage or a different action registration mechanism.

src/com/maddyhome/idea/vim/action/change · high confidence

The core command and change groups in the IdeaVim plugin have been rewritten from Java to Kotlin and refactored to use the new option accessor API and the new undo services (VimKeyBasedUndoService and VimTimestampBasedUndoService). This change improves undo grouping for repeat insertions and block inserts, ensuring that a single undo command correctly reverts logical changes. It also introduces new IntelliJ-specific options such as 'ideawrite', 'idearefactormode', and 'ideaeditor', and adds support for control character highlighting in the editor. The refactoring also includes migrating file and search operations to use the new RPC-based architecture for better compatibility with split mode and thin clients.

src/main/java/com/maddyhome/idea/vim/group · high confidence

The caret API in the editor scope has been updated to align more closely with Vim's native behavior. The \updateCaret\ function now mimics Vim's \cursor()\ logic, extending an active selection from its anchor to the new offset or moving the caret without creating a selection if none is active. Additionally, the \Range.Block\ API has been refactored to use explicit start and end offsets instead of array-based definitions, and the \CaretTransaction\ interface now extends \EditorAccessor\ while removing suspend modifiers from read/write action functions to streamline execution.

api/src/main/kotlin/com/intellij/vim/api/scopes/editor/caret · high confidence

The insert-mode action classes in the \src/com/maddyhome/idea/vim/action/change/insert\ package have been removed. These files previously extended \EditorAction\ and instantiated specific handlers (e.g., \InsertAfterCursorHandler\). This change is part of a broader migration to \VimCommandAction\ and \EditorActionHandlerBase\, simplifying action registration and handler management within the plugin.

src/com/maddyhome/idea/vim/action/change/insert · high confidence

The \MotionEditorAction\ wrapper classes in the \src/com/maddyhome/idea/vim/action/motion/leftright\ package (such as \MotionLeftAction\, \MotionRightAction\, and related column/match-char actions) have been removed. These actions now delegate directly to their corresponding handlers (e.g., \MotionLeftHandler\), simplifying the action hierarchy and removing the intermediate action layer for horizontal cursor movements.

src/com/maddyhome/idea/vim/action/motion/leftright · high confidence

The screen motion action classes (such as MotionFirstScreenLineAction and MotionLastScreenLineAction) have been removed. These actions previously extended MotionEditorAction and instantiated specific handlers; the change simplifies the architecture by using handlers directly, removing the intermediate action wrapper layer for these specific screen navigation commands.

src/com/maddyhome/idea/vim/action/motion/screen · medium confidence

The action classes in the updown motion package (such as MotionDownAction, MotionUpAction, and related line-navigation actions) have been removed. These actions previously extended MotionEditorAction and instantiated specific handlers; the change consolidates this by using handlers directly, simplifying the action hierarchy for vertical cursor movements.

src/com/maddyhome/idea/vim/action/motion/updown · high confidence

The listener package has been restructured to improve stability and consistency. A new IJEditorFocusListener now ensures editors (such as consoles) consistently enter Insert mode upon focus, while run/debug consoles correctly revert to Normal mode. The system now fires FocusGained/FocusLost autocmd events on application-level activation changes. Additionally, a new ModelessSelection handler implements Vim's 'modeless-selection' behavior for mouse gestures, and Rider-specific fixes prevent unwanted line breaks in Insert mode and correct word-selection caret positioning.

src/main/java/com/maddyhome/idea/vim/listener · high confidence

The binary operator handlers in the Vim script engine have been reorganized into a structured hierarchy of base classes and consolidated files, introducing support for new operations and fixing existing behaviors. Arithmetic operators now correctly handle Float coercion, bitwise shift operators (\<\<, \>\>) are implemented, and the equality operator (==) now supports Lists, Dictionaries, and Funcrefs. Comparison operators have been refined to properly prioritize Number over String and handle case-insensitivity via the ignorecase option, while the 'is' and 'isnot' operators now correctly distinguish between value equality for primitives and reference equality for complex types like Lists and Dictionaries. Additionally, the concatenation operator now supports Float-to-String conversion, and the 'DoesNotMatch' operator has been corrected to properly negate the match result.

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/model/expressions/operators/handlers/binary · high confidence

The editor access API has been restructured to improve thread safety and usability. The previous \Read\ interface has been renamed to \EditorAccessor\, which now provides read-only access to editor state (text, lines, marks, jumps) without implying locks. A new \ReadScope\ interface extends \EditorAccessor\ and adds caret-specific operations like \forEachCaret\, \with\, and \withPrimaryCaret\ for safe read access. A new \Transaction\ interface extends \EditorAccessor\ for write operations, adding capabilities to add/remove carets, manage highlights, and manipulate marks and jumps. The \EditorScope\ class now provides \read\ and \change\ entry points that execute blocks under appropriate locks, with the blocks themselves being non-suspend to run within the lock context.

api/src/main/kotlin/com/intellij/vim/api/scopes/editor · high confidence

The line-joining commands (gJ and J) in Normal and Visual modes now check the \ideajoin\ option to decide whether to use the IntelliJ IDEA native join logic or the traditional Vim-style deletion and joining. This allows users to toggle between IDE-aware line joining (which preserves indentation and formatting according to editor settings) and standard Vim behavior via the \ideajoin\ setting.

src/main/java/com/maddyhome/idea/vim/action/change/delete · high confidence

The plugin's startup and event-handling logic has been restructured to improve modularity and stability. A new \IjVimPluginActivator\ now explicitly manages the activation and deactivation lifecycle, ensuring commands, extensions, and functions are registered in a strict order before the \\~/.ideavimrc\ is executed, and properly cleaning up the command line state on disable to prevent NPEs. A \PluginStartup\ class handles project-level initialization, including EAP subscription and search highlight clearing. A new \EventFacade\ centralizes IntelliJ editor event subscriptions (cursors, folding, mouse, etc.) and typed action handling, while \RegisterActions\ now supports pluggable command providers. Additionally, a workaround for Jupyter notebooks (VIM-2487) ensures \.ipynb\ files are closed correctly when a project closes if the \ideaclosenotebooks\ option is set.

src/main/java/com/maddyhome/idea/vim · high confidence

The release automation logic in the scripts module has been reorganized into distinct files to improve maintainability and integration with YouTrack. A new \ktor.kt\ file centralizes HTTP client configuration for YouTrack API calls, including bearer token authentication via the \YOUTRACK\_TOKEN\ environment variable. The \releaseActions.kt\ script now serves as the entry point for release workflows, handling version checks and ticket status updates while skipping patch releases. The \youtrack.kt\ file contains dedicated functions for interacting with YouTrack, such as fetching tickets, setting statuses, adding comments, and managing fix versions, replacing previous inline implementations.

scripts/src/main/kotlin/scripts · high confidence

The visual mode action classes (VisualExitModeAction, VisualSelectPreviousAction, VisualSwapEndsAction, VisualSwapSelectionsAction, VisualToggleCharacterModeAction, and VisualToggleLineModeAction) have been removed from the codebase. These classes previously extended EditorAction and delegated to specific handlers; their removal indicates a shift in how visual mode commands are processed, likely consolidating action handling logic elsewhere in the plugin.

src/com/maddyhome/idea/vim/action/motion/visual · high confidence

The internal structure of the Vim emulator's action handling has been reorganized to improve code clarity and maintainability. Specifically, the \AbstractEditorActionHandler\ class has been removed, and its functionality has been integrated into or replaced by more specific handler classes such as \ChangeEditorActionHandler\, \VisualOperatorActionHandler\, and \ExEntryHandler\. This change simplifies the inheritance hierarchy and aligns the handler implementations with the current command execution flow, ensuring that actions like visual mode operations, ex commands, and text changes are processed through a more direct and robust mechanism. Users will benefit from more stable and predictable behavior when performing complex editing actions, although no new user-facing features are introduced.

src/com/maddyhome/idea/vim/handler · high confidence

The internal classes AbstractRange, LineNumberRange, and MarkRange in the ex/range package have been removed. This change affects the internal structure of how Vim command-line ranges are parsed and resolved, likely as part of a broader refactoring to simplify the codebase or migrate to a new range handling mechanism, though the specific replacement implementation is not visible in this diff.

src/com/maddyhome/idea/vim/ex/range · medium confidence

The Vim plugin now better respects IDE context when the Tab key is pressed. It introduces a new action promoter that ensures IDE features like Live Template expansion and Emmet patterns are triggered before Vim shortcuts, unless the user has explicitly remapped Tab. Additionally, Vim actions are prevented from interfering with Live Template expansion in Normal mode, ensuring that text is not modified unexpectedly outside of Insert or Replace modes.

src/main/java/com/maddyhome/idea/vim/key · high confidence

The abstract \MotionEditorAction\ class, which previously served as the base for motion actions by delegating to \MotionEditorActionHandler\, has been removed from the codebase. This change eliminates the intermediate action layer, indicating a refactoring of how motion commands are structured and executed within the plugin.

src/com/maddyhome/idea/vim/action/motion · high confidence

The dedicated handler classes for undo, redo, and repeat operations (UndoHandler, RedoHandler, and RepeatChangeHandler) have been removed from the change handler package. This refactoring eliminates the explicit command-execution logic previously contained in these files, indicating that the underlying undo/redo and repeat functionality has been consolidated or migrated to a different part of the editor integration.

src/com/maddyhome/idea/vim/handler/change · medium confidence

The specific handler classes for Vim change operations (such as \ChangeMotionHandler\, \ChangeVisualHandler\, and case-modification handlers like \ChangeCaseLowerMotionHandler\) and indentation shifts (\ShiftLeftMotionHandler\, \ShiftRightVisualHandler\, etc.) have been removed from the \src/com/maddyhome/idea/vim/handler/change\ directory. This change eliminates the individual action handler implementations that previously delegated to the \CommandGroups\ service, indicating a structural refactoring of how these editing commands are processed within the plugin.

src/com/maddyhome/idea/vim/handler/change/change · high confidence

The specific action wrapper classes for shifting lines left and right (ShiftLeftLinesAction, ShiftLeftMotionAction, ShiftLeftVisualAction, ShiftRightLinesAction, ShiftRightMotionAction, and ShiftRightVisualAction) have been removed from the codebase. These classes previously extended IntelliJ's EditorAction and delegated to their respective handlers; their removal indicates a shift in how these commands are registered and executed, likely consolidating them into a unified command handling mechanism elsewhere in the plugin.

src/com/maddyhome/idea/vim/action/change/shift · high confidence

The \src/com/maddyhome/idea/vim/action/motion/text/\ directory has been cleaned up by removing several thin wrapper classes (such as \MotionNthCharacterAction\, \MotionWORDLeftAction\, and \MotionWordRightAction\). These classes previously extended \MotionEditorAction\ solely to instantiate and pass a specific handler to the parent constructor. This change eliminates the unnecessary indirection layer, relying instead on the direct handler implementations defined in the \handler.motion.text\ package.

src/com/maddyhome/idea/vim/action/file, src/com/maddyhome/idea/vim/action/motion/text · high confidence

The specific handler classes for copy and paste operations (PutTextAfterCursorHandler, PutTextBeforeCursorHandler, PutVisualTextHandler, YankLineHandler, YankMotionHandler, YankVisualHandler, and YankVisualLinesHandler) have been removed. These handlers previously delegated their execution logic directly to the CommandGroups copy module; this change consolidates the implementation by removing these intermediate wrapper classes, relying on the underlying CommandGroups methods for the actual copy and paste behavior.

src/com/maddyhome/idea/vim/handler/copy · high confidence

The \CharacterHelper\, \EditorData\, \EditorHelper\, \RunnableHelper\, and \SearchHelper\ classes in the \src/com/maddyhome/idea/vim/helper\ package have been removed. These legacy Java utilities, which previously handled character classification, editor metadata storage, cursor position calculations, command execution, and text search logic, are no longer part of the codebase, indicating a migration of these responsibilities to Kotlin-based equivalents.

src/com/maddyhome/idea/vim/helper · high confidence

The \Argument\, \Command\, \CommandState\, and \VisualRange\ classes in the \src/com/maddyhome/idea/vim/command\ package have been removed. This cleanup eliminates the previous monolithic structures used for tracking command arguments, execution types, and global state, reflecting a broader refactoring to modernize how Vim commands and modes are handled internally.

src/com/maddyhome/idea/vim/command · high confidence

The specific action wrapper classes for mark-related motions (MotionGotoFileMarkAction, MotionGotoFileMarkLineAction, MotionGotoMarkAction, MotionGotoMarkLineAction, and MotionMarkAction) have been removed from the codebase. These classes previously extended EditorAction or MotionEditorAction to delegate to their respective handlers; their deletion indicates a shift in how these commands are registered or executed, likely moving away from the explicit action class structure toward a handler-centric or plugin-xml-defined mapping approach.

src/com/maddyhome/idea/vim/action/motion/mark · medium confidence

The ReplaceWithRegister extension has been rewritten to use the new IdeaVim API, replacing the previous implementation. This change introduces support for multiple carets (multi-cursor) and improves handling of visual block mode replacements. The extension now registers mappings for normal mode (gr, grr) and visual mode (gr) via the new plugin action system and exports an operator function to handle the core replacement logic, ensuring compatibility with modern IdeaVim internals.

src/main/java/com/maddyhome/idea/vim/extension/replacewithregister · high confidence

The scroll action classes in the motion package have been removed. These classes previously extended EditorAction and delegated to specific handlers; their removal indicates a shift in how scroll commands are handled, likely consolidating logic into the handler layer or a new action system.

src/com/maddyhome/idea/vim/action/motion/scroll · medium confidence

The unary operator handlers for arithmetic operations (such as negation and identity) have been refactored to use a shared base class that explicitly handles type conversion between VimFloat and integer types, ensuring consistent behavior when applying unary operators to numeric values.

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/model/expressions/operators/handlers/unary · medium confidence

The command-line API now exposes distinct scopes for safe interaction: \CommandLineRead\ provides non-suspending access to the current text, caret position, and active state under a read lock, while \CommandLineTransaction\ allows text modification, caret movement, and closing the command line under a write lock. The \CommandLineScope\ class introduces \read\ and \change\ methods to enforce these locking semantics, and the \input\ method now accepts a suspendable callback to handle user input asynchronously without blocking the thread.

api/src/main/kotlin/com/intellij/vim/api/scopes/commandline · high confidence

Window navigation commands (such as Ctrl-w h/j/k/l) now treat docked tool windows as navigable targets alongside editor splits. The implementation in WindowGroup collects both editor panes and visible docked tool windows, allowing users to move focus between code editors and UI panels (like Project or Terminal) using the same directional keys, rather than being restricted to editor-only navigation.

IdeaVIM · high confidence

The TeamCity project configuration script has been updated to use the 2025.11 version of the Kotlin DSL. This change aligns the project's CI configuration with the newer DSL API, ensuring compatibility with the latest TeamCity server features and syntax requirements.

.teamcity · high confidence

IdeaVim now handles user-defined key mappings when no editor is open (e.g., when focus is on the project view or search fields). A new \OutsideEditorKeyDispatcher\ registers custom shortcuts for mappings that execute IDE actions, allowing users to continue their workflow without an active text editor. Additionally, the \\<C-L\>\ command now explicitly clears and redraws the screen, which helps refresh the status line in these contexts.

src/main/java/com/maddyhome/idea/vim/action · high confidence

The VimScriptGlobalEnvironment class in the ex.vimscript package is now deprecated and scheduled for removal in version 1.12. Users relying on this class for managing Vim script variables should migrate to VariableService, as direct access to the global environment is being phased out to improve API stability and encapsulation.

src/main/java/com/maddyhome/idea/vim/ex · high confidence

Corrected behavior in the Vimscript collection functions: the count() function now correctly handles the start index argument, the get() function properly supports negative indices for list access, and the remove() function now enforces the correct minimum arity.

vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/model/functions/handlers/collectionFunctions · high confidence

The mode widget listener now uses a recursion guard when retrieving the currently focused editor. This prevents potential infinite recursion or stack overflow issues that could occur during mode updates, ensuring the Vim mode indicator remains stable and responsive.

src/main/java/com/maddyhome/idea/vim/ui/widgets/mode/listeners · high confidence

Add Matchit extension tests for CMake, C, GNU Make, HTML, PHP, Ruby, and user-defined patterns; Added MockTestCase base class for IDEVim tests; Added PyCharm UI test for Python Console interaction; Added UI test fixtures and utilities for IntelliJ Platform; Added UI tests for Rider license activation and basic editing; Added UI tests for message area, showcmd, and vimrc reloading; Added comprehensive test coverage for delete and shift actions; Added comprehensive test coverage for the Vim Surround extension; Added long-running tests for IdeaVim macros and mappings; Added parser expression tests for Vimscript syntax; Added parser tests for Vimscript statements; Added property-based tests for IdeaVim command execution; Added split-mode test coverage for IdeaVim; Added test annotations for primary clipboard support; Added test coverage for Ex command implementations; Added test coverage for Vim collection functions; Added test coverage for Vim ex command statements; Added test coverage for Vim list manipulation functions; Added test coverage for Vimscript function implementation details; Added test coverage for key mapping and search functionality; Added test coverage for the new autocmd system; Added test for macro execution with arrow keys; Added tests for CaretTransaction API behavior; Added tests for MiniAI extension bracket and quote handling; Added tests for NERDTree extension behaviors; Added tests for ReplaceWithRegister extension behavior; Added tests for Select mode actions and state transitions; Added tests for Vim change actions and number manipulation; Added tests for Vim expression evaluation; Added tests for Vim extension key mappings and lifecycle; Added tests for Vim float builtin functions; Added tests for Vim history functions; Added tests for Vim mapping and digraph functions; Added tests for Vim option mappers in IntelliJ; Added tests for Vim regex engine edge cases; Added tests for Vim script functions; Added tests for Vim special variables; Added tests for Vim string functions; Added tests for Vim variable service behavior; Added tests for VimApi mode, search, and variable scopes; Added tests for VimApi transaction mark operations; Added tests for VimScript text transformation functions; Added tests for Vimscript bitwise functions; Added tests for Vimscript parser executable text ranges; Added tests for YouCompleteMe action promotion logic; Added tests for call(), function(), and funcref() Vim functions; Added tests for command counts and mode widget status strings; Added tests for command history window actions; Added tests for copy and paste actions; Added tests for cursor position functions; Added tests for dictionary functions; Added tests for gn/gN text object and visual selection motions; Added tests for horizontal and vertical caret scrolling behavior; Added tests for horizontal and vertical scrolling actions; Added tests for incremental search and substitute preview highlighting; Added tests for insert mode actions; Added tests for left/right motion edge cases; Added tests for mark actions and tag stack navigation; Added tests for mouse option and listener lifecycle; Added tests for paragraph motion extension; Added tests for register actions and test helper utilities; Added tests for screen-line motion commands (H, M, L); Added tests for search motion actions and max search count display; Added tests for select-mode motion commands; Added tests for text motion commands; Added tests for the Abolish extension; Added tests for the GetLine text function; Added tests for the Highlighted Yank extension; Added tests for the Hint system and TableEverywhere extension; Added tests for the Vim signature extension; Added tests for the Visual Star Search extension; Added tests for the getcmdtype() command-line function; Added tests for the gx URL-opening command; Added tests for the indentwise extension navigation commands; Added tests for the multiple-cursors extension; Added tests for the new experimental VimEditor API; Added tests for the textobj-entire Vim extension; Added tests for the textobj-indent extension; Added tests for the textobj-line extension; Added tests for the textobj-user extension; Added tests for thin API digraph, editor context, modal input, and option scopes; Added tests for undo, change, and operator actions; Added tests for vertical motion and selection behavior; Added tests for visual mode actions and selection behavior; Added tests for visual mode selection control and non-Vim visual changes; Added unit tests for Ex command parsing and execution; Added unit tests for Vim expression data types; Added unit tests for Vim helper utilities; Added unit tests for the tabmove command; Added unit tests for the thin API read operations; Expanded test coverage for IdeaVim editor actions; Expanded test coverage for Vim options and key mappings; Expanded test coverage for Vim text objects and motions; Expanded test coverage for Vimscript expression operators; Expanded test coverage for command-line actions and insertions; Initial UI test suite for IdeaVim; Java-specific test suite for IdeaVim; New test fixture infrastructure for IdeaVim.

The project now includes a Gradle wrapper configuration file that pins the build tool to version 9.7.1. This ensures that all developers and CI systems use the same specific Gradle distribution, downloaded from the official services URL, with standard network timeout and retry settings.

gradle · high confidence

The IdeaVim build system has been upgraded to Kotlin 2.3.20 and the IntelliJ Platform Gradle Plugin 2.18.0. This update includes a bump to the JUnit 6 test framework and KSP 2.3.7, and configures the build to target Java 21. The project structure has been reorganized into multiple content modules (such as \ideavim-backend-bookmarks-core\ and \ideavim-backend-bookmarks\) to handle platform-specific dependencies like the separate bookmarks plugin in newer IDE versions.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 43 → 50 (+6.2)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 60 → 84 (+24.7)
• Architecture 97 → 87 (-10.1)
• Maturity 57 → 59 (+1.2)
• Readiness 24 → 66 (+42.3)
• Security 58 → 45 (-12.4)
• Accessibility 41 (new)

• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (scripts-ts/package-lock.json)
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/handler/MotionActionHandler.kt)
• Duplicated block (10 lines × 2) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/options/Option.kt)
• Duplicated block (10 lines × 2) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/parser/visitors/CommandVisitor.kt)
• Duplicated block (10 lines × 3) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/parser/visitors/ExpressionVisitor.kt)
• Duplicated block (11 lines × 2) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/api/VimSearchHelperBase.kt)
• Duplicated block (12 lines × 2) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/regexp/parser/visitors/PatternVisitor.kt)
• Duplicated block (13 lines × 2) (scripts/src/main/kotlin/scripts/youtrack.kt)
• Duplicated block (13 lines × 2) (src/main/java/com/maddyhome/idea/vim/extension/matchit/Matchit.kt)
• Duplicated block (13 lines × 2) (src/main/java/com/maddyhome/idea/vim/extension/matchit/Matchit.kt)
• Duplicated block (13 lines × 2) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/regexp/parser/visitors/PatternVisitor.kt)
• Duplicated block (14 lines × 2) (src/main/java/com/maddyhome/idea/vim/extension/nerdtree/NerdTree.kt)
• Duplicated block (14 lines × 3) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/model/statements/loops/ForLoop.kt)
• Duplicated block (16 lines × 2) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/api/VimKeyGroupBase.kt)
• Duplicated block (16 lines × 2) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/regexp/parser/visitors/PatternVisitor.kt)
• Duplicated block (16 lines × 2) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/model/statements/loops/ForLoop.kt)
• Duplicated block (17 lines × 2) (scripts/src/main/kotlin/scripts/release/util.kt)
• Duplicated block (17 lines × 2) (scripts/src/main/kotlin/scripts/youtrack.kt)
• …and 69 more

• Address.createRangeAddresses (cognitive 17) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/ex/ranges/Address.kt)
• ArgBoundsFinder.skipSexp (cognitive 21) (src/main/java/com/maddyhome/idea/vim/extension/argtextobj/VimArgTextObjExtension.kt)
• AssignmentOperator.validateValues (cognitive 16) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/model/expressions/operators/AssignmentOperator.kt)
• AssignmentOperator.validateValues (cyclomatic 16) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/vimscript/model/expressions/operators/AssignmentOperator.kt)
• BacktrackingStrategy.simulate (cognitive 22) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/regexp/engine/strategies/BacktrackingStrategy.kt)
• Boundary-crossing change coupling: ExEditorKit.kt ↔ InsertCompletedDigraphAction.kt (src/main/java/com/maddyhome/idea/vim/ui/ex/ExEditorKit.kt)
• Boundary-crossing change coupling: ExEditorKit.kt ↔ InsertCompletedLiteralAction.kt (src/main/java/com/maddyhome/idea/vim/ui/ex/ExEditorKit.kt)
• Boundary-crossing change coupling: IjEditorExecutionContext.kt ↔ MappingInfo.kt (src/main/java/com/maddyhome/idea/vim/newapi/IjEditorExecutionContext.kt)
• Boundary-crossing change coupling: IjVimApplication.kt ↔ VimApplication.kt (src/main/java/com/maddyhome/idea/vim/newapi/IjVimApplication.kt)
• Boundary-crossing change coupling: IjVimMessages.kt ↔ VimMessages.kt (src/main/java/com/maddyhome/idea/vim/newapi/IjVimMessages.kt)
• Boundary-crossing change coupling: MacroGroup.kt ↔ InsertCompletedDigraphAction.kt (src/main/java/com/maddyhome/idea/vim/group/MacroGroup.kt)
• Boundary-crossing change coupling: MacroGroup.kt ↔ InsertCompletedLiteralAction.kt (src/main/java/com/maddyhome/idea/vim/group/MacroGroup.kt)
• BracketNormalizer.findCollectionEnd (cognitive 20) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/regexp/parser/BracketNormalizer.kt)
• BracketNormalizer.findCollectionEnd (cyclomatic 17) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/regexp/parser/BracketNormalizer.kt)
• BracketNormalizer.normalize (cognitive 24) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/regexp/parser/BracketNormalizer.kt)
• BracketNormalizer.normalize (cyclomatic 18) (vim-engine/src/main/kotlin/com/maddyhome/idea/vim/regexp/parser/BracketNormalizer.kt)
• BufferCommand.processCommand (cognitive 29) (src/main/java/com/maddyhome/idea/vim/vimscript/model/commands/BufferCommand.kt)
• CI installs an unverified third-party binary (.github/workflows/codebaseMaintenance.yml)
• CamelCaseMotionKt.isSubWordStart (cyclomatic 18) (src/main/java/com/maddyhome/idea/vim/extension/camelcasemotion/CamelCaseMotion.kt)
• Change coupling clique: MiniAI.kt, ParagraphMotion.kt, VimIndentObject.kt (src/main/java/com/maddyhome/idea/vim/extension/miniai/MiniAI.kt)
• …and 776 more

• 155 commits — 138 feature/other, 17 fixes

• (root) — 36 commits
• src/main — 36 commits
• vim-engine/src — 35 commits
• src/test — 22 commits
• .teamcity/_Self — 3 commits
• scripts-ts/src — 3 commits
• src/testFixtures — 3 commits
• annotation-processors/build.gradle.kts — 2 commits
• doc/IdeaVim Plugins.md — 2 commits
• ideavim-backend/src — 2 commits
• scripts/build.gradle.kts — 2 commits
• .github/actions — 1 commit
• .github/workflows — 1 commit
• api/build.gradle.kts — 1 commit
• doc/NERDTree-support.md — 1 commit
• doc/set-commands.md — 1 commit
• gradle/wrapper — 1 commit
• ideavim-frontend/src — 1 commit
• tests/java-tests — 1 commit
• tests/split-mode-tests — 1 commit

• fix: Fix IndexOutOfBoundsException expanding a word object at the start of the file
• fix: Fix g8 crashing when there is no character under the caret
• fix: Fix property-based workflow
• fix: Fix(VIM-1341): gx should not add to the jump list
• fix: Fix: AssertionError when yanking with a blockwise-forced motion (y<C-V>)
• fix: Fix: IndexOutOfBoundsException inserting the filename under the caret at the end of the document
• fix: Update changelog: % expansion in ex commands, blockwise yank and CTRL-R CTRL-F fixes
• fix: Update changelog: 2.46.2 release, nested block delete fix
• fix: Update changelog: fix for NPE when unloading the plugin
• fix: Update changelog: repeat with auto-import fix
• fix: VIM-1370 Fix tag command to last position on stack
• fix: VIM-2010 fix editor leak in tc tests
• fix: VIM-2010 fix repeat insert with import
• fix: VIM-2074 Fix backspace in replace mode
• fix: fix for caret position after ChangeVisualCharacter
• fix: fix range of visual selection
• fix: fix test related to changeVisualCharacter
• change: Add 2026.2 to teamcity builds
• change: Add bookmarks plugin module
• change: Add idea prefix to custom options
• …and 135 more

• Containers 0 added · 0 removed · contexts 8 added · 0 removed · edges 7 added · 0 removed

• IdeaVIM
• annotation-processors
• api
• ideavim-backend
• ideavim-common
• repository
• scripts
• vim-engine

• ideavim-backend → ideavim-common
• ideavim-backend → vim-engine
• ideavim-common → vim-engine
• repository → api (coupling)
• repository → ideavim-common
• repository → vim-engine (coupling)
• vim-engine → api (coupling)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

JetBrains/ideavim was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.