VSCode Neovim: Gdscript Visual Mode Commenting Bug

Alex Johnson

-Nov 15, 2025

VSCode Neovim: Gdscript Visual Mode Commenting Bug

Introduction to the gdscript Commenting Issue

In the world of VSCode Neovim, we strive for a seamless coding experience that blends the power of Vim's editing capabilities with the modern features of Visual Studio Code. However, a peculiar bug has surfaced, specifically impacting the ability to comment code within gdscript files using the gc command in visual mode. This article delves into the specifics of this issue, exploring why it happens, what the expected behavior is, and how you might navigate around it until a permanent fix is implemented. We understand how frustrating it can be when a core editing function doesn't behave as anticipated, especially when it's tied to a specific file type. This problem report aims to provide clarity and gather community support for resolving this vscode-neovim quirk.

Understanding the `gc` Command in Visual Mode

The gc command in Vim and Vim-emulating plugins like vscode-neovim is a fundamental tool for code commenting. When you enter visual mode (by pressing v, V, or Ctrl+V), select a block of text, and then press gc, the expectation is that the selected lines or text will be commented according to the language's syntax. For gdscript, this typically means prefixing each line with #. This command is a significant time-saver, allowing developers to quickly comment out sections of code for debugging or temporary removal without manual intervention. The fact that this specific command fails only in .gd files within vscode-neovim, while working in other contexts, points to a nuanced interaction between the plugin, the gdscript language server, and VSCode's handling of file-specific configurations. The vscode-neovim plugin aims to replicate Neovim's behavior as closely as possible within VSCode, and this particular discrepancy is a key area of investigation for users who rely on these advanced editing shortcuts.

The gdscript `gc` Bug in Detail

The core of the problem is that when a user selects text in visual mode within a .gd file in VSCode and presses gc, the expected commenting action does not occur. Instead, the visual selection is simply deselected, leaving the code uncommented. This is particularly baffling because other commenting methods do work as expected. For instance, using gcc in normal mode to comment an entire line functions correctly. Furthermore, VSCode's built-in commenting shortcut (Ctrl+/ in insert mode) also successfully comments the selected text. Even more curiously, the gc command does work for commenting in other file types within vscode-neovim, although sometimes with slightly different behavior (e.g., using /* */ for block comments in Rust instead of line comments). This selective failure suggests that the issue is not a general inability of vscode-neovim to handle commenting, but rather a specific incompatibility or misconfiguration related to gdscript files. The developers have confirmed that they have taken several troubleshooting steps, including setting vscode-neovim.neovimClean and restarting VSCode, and have consulted the plugin's documentation and existing issues without success. The Neovim version used is v0.11.2 Release, and the VSCode version is 1.106.0 on Windows 10. The lack of specific log messages in the output window further complicates debugging efforts, as it leaves little direct evidence of what might be going wrong during the gc command execution.

Reproducing the gdscript Commenting Issue

To help diagnose and fix this bug, it's crucial to be able to reproduce it reliably. The steps outlined by the reporter are straightforward and do not necessarily require a full Godot engine setup, though it's provided as a potential additional context. Here’s a breakdown of how to trigger the issue:

Open a gdscript file: Create or open any file with the .gd extension in VSCode. The provided example code snippet is a good starting point.

@tool
extends Node

@export var source_node: Control
@export var target_node: Control
@export_tool_button("Mimic Now") var btn0 = mimic

func _ready():
    var err := 0
    if source_node == null:
        err += 1
    if target_node == null:
        err += 1
    if err > 0:
        return

    source_node.connect("resized", _on_source_resized)

func mimic():
    if source_node == null or target_node == null:
        return
    _on_source_resized()

func _on_source_resized():
    target_node.custom_minimum_size = source_node.size

Enter Visual Mode: Press v (character-wise visual mode), V (line-wise visual mode), or Ctrl+V (block-wise visual mode) to enter visual mode.
Select Lines: Use your cursor or Vim's movement keys to highlight the block of code you wish to comment out. For example, select the entire _ready() function or a few lines within it.
Press gc: With the lines still highlighted, press the g key followed by the c key.

Expected Outcome: The selected lines should be commented with # at the beginning of each line.

Actual Outcome: The visual selection is removed, and no commenting occurs. The code remains as it was.

This simple reproduction sequence highlights the specific failure point. The fact that other commenting methods work underscores that the underlying commenting functionality likely exists within the plugin and VSCode environment but is failing to engage correctly for gc in visual mode specifically on gdscript files. The optional Godot setup details are provided in case there's an interaction with the Godot Language Server or specific gdscript parsing that vscode-neovim relies on, though the reporter suspects this is unlikely given Neovim's standalone success with gdscript commenting. The absence of clear error logs makes direct troubleshooting challenging.

Expected vs. Actual Behavior: A Clear Distinction

The discrepancy between what should happen and what is happening is central to this bug report. When using gc in visual mode on a gdscript file within vscode-neovim, the code remains uncommented, and the visual selection is simply exited. This deviates significantly from the intended functionality of the gc command, which is designed to intelligently comment selected text based on the file's language syntax. For gdscript, this means adding a # at the start of each selected line.

Let's contrast this with the expected behavior and other working methods:

Expected Behavior with gc: Upon selecting lines in visual mode and pressing gc, each selected line should be prefixed with # , effectively commenting out that portion of the code. The visual mode should then be exited.
Working Method 1: gcc in Normal Mode: Pressing gcc while your cursor is on a line (or while lines are selected in visual mode, though this is less common for gcc) successfully comments out that specific line with # .
Working Method 2: VSCode's Built-in Commenting: Using VSCode's native commenting shortcut (typically Ctrl+/ when in insert mode, or Cmd+/ on macOS) on selected lines correctly applies comments (# for gdscript).
Working Method 3: gc in Other File Types: The gc command functions for commenting in other file types like Rust, although the style of commenting might differ. For instance, Rust code might be commented using /* */ block comments in vscode-neovim's gc command, whereas standard Neovim might opt for line comments (//). This indicates that vscode-neovim can apply language-specific commenting rules, but something is preventing it from doing so for gdscript's gc in visual mode.
Working Method 4: Neovim (Standalone): The reporter notes that commenting using gc in visual mode works perfectly in a standalone Neovim installation, even without specific Godot configurations or LSP setups. This strongly suggests that the issue lies within the vscode-neovim plugin's integration or its interaction with VSCode's environment, rather than a fundamental limitation of gdscript commenting itself.

This clear distinction highlights that the problem is not a lack of commenting capability but a specific failure in the gc visual mode command for gdscript files within the vscode-neovim context. The fact that other methods work provides valuable clues for debugging, pointing towards an issue with how vscode-neovim's mapping or its communication with the language server handles this particular command and file type combination.

Potential Causes and Debugging Avenues

While the exact root cause of the gdscript gc commenting bug in vscode-neovim remains elusive without direct log output, we can explore several potential areas where the issue might stem from. Understanding these possibilities can guide further investigation and troubleshooting efforts by the vscode-neovim developers and the community.

Language Server Interaction: gdscript files often rely on a language server (like godot-tools in VSCode) for features such as syntax highlighting, code completion, and refactoring. It's possible that vscode-neovim attempts to delegate the commenting action to the language server, and there's a miscommunication or an unsupported command. Unlike standalone Neovim, vscode-neovim has to bridge Vim's commands with VSCode's Language Server Protocol (LSP) or other VSCode APIs. If the gdscript LSP doesn't expose a specific textDocument/comment or equivalent functionality that vscode-neovim can hook into for visual mode gc, it might fail.
Mapping Conflicts or Overrides: There might be a conflict with existing key mappings within VSCode or vscode-neovim itself that are inadvertently overriding or interfering with the gc command's intended behavior for gdscript files. Sometimes, extensions or user-defined settings can introduce custom mappings that inadvertently shadow built-in Vim commands. The fact that gc works in other file types suggests that the general mapping for gc might be present, but a specific configuration or interaction related to gdscript is causing it to fail.
Syntax-Specific Logic Errors: The vscode-neovim plugin needs to understand the comment syntax for each language. For gdscript, the comment character is #. The plugin might have an internal mechanism to detect the file type and apply the correct comment string. There could be a bug in this detection logic or in how the comment string is applied specifically when the gc command is triggered in visual mode for .gd files. The difference in behavior observed with Rust comments (block vs. line) also hints at potential subtleties in how the plugin handles language-specific comment insertion.
VSCode API Limitations or Quirks: While VSCode provides powerful APIs for extensions, there might be certain edge cases or limitations in how it handles text manipulation commands initiated through plugins, especially when those commands are Vim-style and operate on selections. The plugin might be encountering an issue when trying to use VSCode's TextEditorEdit API to insert comments in the way gc expects for a visual selection in a .gd file.
Neovim Configuration Differences: Although the user has tried neovimClean, subtle differences in how vscode-neovim interprets or forwards Vim commands compared to a standalone Neovim instance could be at play. This could involve how selections are passed or how commands are executed within the VSCode environment.

Debugging Steps:

Enabling Verbose Logging: The reporter mentioned difficulty finding the log output. Enabling verbose logging within vscode-neovim (often through VSCode's settings.json by adding `