Cómo agregar tu editor al click derecho en Windows 11

Acabás de crear una carpeta nueva en el Explorador de Windows. Click derecho. Buscás algo que diga Open with VS Code, Open with Cursor, Open with Windsurf... y no aparece. O peor: aparece, le das click, y no pasa nada.

Es un flujo trivial — crear carpeta, abrirla en tu editor — pero Windows lo hace sorprendentemente difícil en 2026. Las recetas que encontrás en blogs y respuestas de Stack Overflow son de hace cinco o seis años, y omiten dos cambios importantes: el menú contextual rediseñado de Windows 11, y la forma en que los editores basados en Electron manejan sus argumentos.

Esta guía resuelve los dos problemas. Funciona para cualquier editor moderno (VS Code, Cursor, Windsurf, VS Codium, y los forks que vayan apareciendo) y no necesita permisos de administrador. Al final tenés un click derecho que abre la carpeta directamente en el editor, en la primera pantalla del menú, sin pasar por Mostrar más opciones.

El menú contextual nativo no sirve para carpetas

Windows tiene una opción Open with... integrada — pero solo para archivos. Sobre carpetas, el menú nativo te ofrece "Abrir", "Abrir en ventana nueva", "Pin to Quick access" y poco más. No hay una manera oficial de decirle "para carpetas, agregame este editor a la lista".

El reflejo natural es buscar un setting en el editor. Pero esa configuración no existe del lado del editor — el menú contextual lo controla Windows, no la app. Así que vamos a registrar nuestra propia entrada vía Registry.

Principio: el menú contextual de carpetas se extiende desde el sistema operativo, no desde la aplicación. Si un editor lo agrega "automáticamente", lo está haciendo escribiendo en tu Registry durante la instalación.

Las dos entradas de Registry que sí necesitás

Hay dos lugares en el Registry donde Windows lee las entradas custom para carpetas:

• HKCU\Software\Classes\Directory\shell\<tu-clave> — aparece cuando hacés click derecho sobre una carpeta en el Explorador.
• HKCU\Software\Classes\Directory\Background\shell\<tu-clave> — aparece cuando hacés click derecho dentro de una carpeta (sobre el fondo en blanco), y abre esa carpeta donde estás parado.

Las dos son necesarias si querés cobertura completa. Y las dos viven en HKCU (current user) en lugar de HKLM (machine-wide), lo que significa cero permisos de administrador.

El otro detalle no obvio: dentro del subkey command, la variable que recibe la ruta es %1 en Directory\shell, pero %V en Directory\Background\shell. Confundirlas es una de las razones por las que la mayoría de las recetas que encontrás falla en uno de los dos casos.

Principio: dos entradas, dos variables. %1 para el click sobre la carpeta, %V para el click dentro de la carpeta.

Pitfall #1: en Windows 11, tu entrada queda escondida

Si seguís cualquier tutorial pre-2022, vas a registrar las entradas correctamente y no las vas a ver al hacer click derecho. Eso es porque Windows 11 introdujo un menú contextual rediseñado, más corto, con apenas cinco o seis opciones visibles. Todo lo demás queda detrás del botón Mostrar más opciones.

Y acá viene la mala noticia: Microsoft solo permite que aparezcan en ese menú nuevo las apps empaquetadas como MSIX que registran un shell extension moderno implementando la interfaz COM IExplorerCommand. Las entradas de Registry tradicionales — que es lo único que podés crear desde fuera del instalador del editor — viven obligatoriamente bajo Mostrar más opciones.

Esto te afecta incluso si el editor está bien instalado. VS Code, Cursor y la mayoría de los forks no aparecen en el menú nuevo de Windows 11 — todos viven detrás de Mostrar más opciones. No es un bug tuyo; es una decisión de Microsoft.

La salida es desactivar el menú nuevo y volver al clásico (el de Windows 10), donde tus entradas custom aparecen junto a las nativas en la primera pantalla. Se hace con un override del CLSID:

$key = "HKCU:\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}\InprocServer32"
New-Item -Path $key -Force | Out-Null
Set-ItemProperty -Path $key -Name "(Default)" -Value ""
Stop-Process -Name explorer -Force; Start-Process explorer

Trade-off honesto: este cambio aplica a todas las apps, no solo a tu editor. Vas a ver el menú clásico siempre. Para muchos desarrolladores eso es un upgrade — el menú nuevo esconde funcionalidad útil — pero conviene que lo decidas a conciencia. Se revierte con un comando de una línea (al final del artículo).

Principio: el menú nuevo de Windows 11 fue diseñado para ser corto y curado. Si querés extenderlo, tenés que volver al clásico.

Pitfall #2: la variable de entorno que sabotea a los editores Electron

Los editores modernos basados en Electron (VS Code y todos sus forks) usan internamente una variable llamada ELECTRON_RUN_AS_NODE. Cuando vale 1, le dice al binario "no abrás una ventana, ejecutate como Node.js y cargá el primer argumento como módulo".

El problema: cuando abrís una terminal integrada dentro del editor, esa terminal hereda ELECTRON_RUN_AS_NODE=1 del proceso padre. Si desde esa terminal lanzás otra cosa que termine ejecutando el binario del editor — por ejemplo un agente que invoca al editor — la variable contamina la nueva invocación. Resultado típico:

Error: Cannot find module 'C:\Users\Tu\Carpeta'
    at Module._resolveFilename ...

El editor está intentando cargar tu carpeta como un paquete de Node. La solución no es debuggear las llamadas; es asegurarte de que la variable nunca llegue al binario del editor cuando lo lanzás desde el menú contextual. Para eso usamos un launcher intermedio — un .cmd de tres líneas que limpia la variable antes de invocar:

@echo off
setlocal
set ELECTRON_RUN_AS_NODE=
start "" "<ruta-completa-al-editor.exe>" "%~1"
endlocal

El start "" hace algo más: desacopla el proceso del editor del proceso del Explorador, para que la ventanita de cmd que ejecuta el launcher se cierre inmediatamente y no se quede colgada esperando que cerrés el editor.

Principio: nunca llames directo al binario de un editor Electron desde el Registry. Pasá siempre por un launcher que limpie el entorno y desacople el proceso.

El flag --new-window también te puede traicionar

Es tentador agregar --new-window al comando para forzar que cada click abra una ventana fresca. La realidad: algunos forks de VS Code ignoran silenciosamente el flag y, peor, en algunos casos rompen el handshake IPC con la instancia que ya está corriendo. Resultado: el comando "no hace nada".

El comportamiento por defecto, sin flags, es razonable: si no hay instancia corriendo, abre fresca; si hay una, reutiliza la ventana. Si te molesta que reutilice, ese es un setting del editor (en VS Code: window.openFoldersInNewWindow), no algo que se resuelve desde Registry.

Principio: Registry resuelve "qué binario invocar y con qué ruta". El comportamiento ventana/instancia lo controla el editor. No mezcles las capas.

Receta completa, lista para copiar

Reemplazá las dos variables de arriba (ruta al ejecutable, nombre del editor) y corré todo el bloque en PowerShell. Funciona igual para VS Code, Cursor, Windsurf, VS Codium y cualquier otro fork de VS Code:

# --- Configurá estas dos líneas ---
$exe   = "C:\ruta\completa\al\editor.exe"   # ej: "$env:LOCALAPPDATA\Programs\VS Code\Code.exe"
$label = "Open with MyEditor"               # texto que vas a ver en el menú
$key   = "MyEditor"                          # nombre interno (sin espacios)
# -----------------------------------

# 1) Crear el launcher que limpia el entorno
$launcher = "$env:USERPROFILE\${key}_launcher.cmd"
@"
@echo off
setlocal
set ELECTRON_RUN_AS_NODE=
start `"`" `"$exe`" `"%~1`"
endlocal
"@ | Set-Content -Path $launcher -Encoding ASCII

# 2) Registrar la entrada para click sobre carpeta
$base1 = "HKCU:\Software\Classes\Directory\shell\$key"
New-Item -Path $base1 -Force | Out-Null
Set-ItemProperty -Path $base1 -Name "(Default)" -Value $label
Set-ItemProperty -Path $base1 -Name "Icon"      -Value "`"$exe`",0"
New-Item -Path "$base1\command" -Force | Out-Null
Set-ItemProperty -Path "$base1\command" -Name "(Default)" -Value "`"$launcher`" `"%1`""

# 3) Registrar la entrada para click dentro de carpeta
$base2 = "HKCU:\Software\Classes\Directory\Background\shell\$key"
New-Item -Path $base2 -Force | Out-Null
Set-ItemProperty -Path $base2 -Name "(Default)" -Value $label
Set-ItemProperty -Path $base2 -Name "Icon"      -Value "`"$exe`",0"
New-Item -Path "$base2\command" -Force | Out-Null
Set-ItemProperty -Path "$base2\command" -Name "(Default)" -Value "`"$launcher`" `"%V`""

# 4) Forzar el menú clásico de Windows 11 (entrada visible en primera pantalla)
$clsid = "HKCU:\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}\InprocServer32"
New-Item -Path $clsid -Force | Out-Null
Set-ItemProperty -Path $clsid -Name "(Default)" -Value ""

# 5) Reiniciar Explorer
Stop-Process -Name explorer -Force; Start-Process explorer

Probalo con click derecho sobre cualquier carpeta. Vas a ver un breve flash de una ventanita negra de cmd — es el launcher ejecutándose y desaparece en menos de un segundo. El editor abre con la carpeta cargada.

Editores nativos no necesitan el launcher

Esta receta es específica para editores Electron. Los IDEs nativos (Sublime Text, Notepad++, los IntelliJ de JetBrains) no tienen el problema de ELECTRON_RUN_AS_NODE y aceptan rutas directamente como argumento. Para ellos podés saltarte el launcher y poner el binario directo en el subkey command:

# Para editores nativos, esta forma simple alcanza
Set-ItemProperty -Path "$base1\command" -Name "(Default)" -Value "`"$exe`" `"%1`""

El override del menú clásico de Win11 (paso 4) sigue siendo necesario si querés que aparezca en la primera pantalla.

Prompt listo para tu agente (la opción sin consola)

Si no querés ejecutar PowerShell vos mismo — no sos técnico, te da pereza, o simplemente preferís delegar — copiá el prompt de abajo y pasáselo a tu agente de IA con acceso a tu computadora (Claude Code, Cursor Agent, Windsurf Cascade, GitHub Copilot Workspace, o cualquier otro que pueda ejecutar comandos en tu terminal).

El prompt está pensado para que el agente haga absolutamente todo: detecta tu editor, crea el launcher, registra las entradas, activa el menú clásico, reinicia el Explorador y te confirma que funciona. Vos solo tenés que decirle qué editor querés agregar.

Necesito que agregues una opción "Open with <mi editor>" al menú contextual
del Explorador de archivos en Windows 11. Quiero ver la opción cuando hago
click derecho sobre cualquier carpeta y también cuando hago click derecho
sobre el fondo en blanco dentro de una carpeta. La opción tiene que aparecer
en la primera pantalla del menú, NO escondida bajo "Mostrar más opciones".

Mi editor es: <completá: VS Code / Cursor / Windsurf / VS Codium / Sublime / etc.>

Por favor hacé todo esto sin pedirme confirmación entre pasos:

1. DETECTAR EL EJECUTABLE
   - Buscá el .exe del editor en %LOCALAPPDATA%\Programs, %ProgramFiles% y
     %ProgramFiles(x86)%.
   - Si no lo encontrás, resolvé el atajo del menú Inicio con
     `Get-StartApps | Where-Object Name -match '<editor>'` y leé el
     TargetPath del .lnk con WScript.Shell.CreateShortcut.
   - Si no aparece por ningún lado, abortá con un mensaje claro pidiéndome
     la ruta manual.

2. CREAR UN LAUNCHER .CMD EN MI CARPETA DE USUARIO
   - Path: %USERPROFILE%\<editor_slug>_launcher.cmd
   - Contenido EXACTO (reemplazando la ruta real al .exe):

     @echo off
     setlocal
     set ELECTRON_RUN_AS_NODE=
     start "" "<ruta_completa_al_editor.exe>" "%~1"
     endlocal

   - El launcher es OBLIGATORIO si el editor está basado en Electron
     (VS Code, Cursor, Windsurf, VS Codium, Antigravity, Trae, etc.) porque
     la variable ELECTRON_RUN_AS_NODE se filtra desde terminales abiertas
     dentro del editor y rompe la invocación directa del .exe desde Registry.
   - Para editores nativos (Sublime Text, Notepad++, JetBrains) podés
     saltarte el launcher y poner el .exe directo en el comando del paso 3.

3. REGISTRAR LAS DOS ENTRADAS EN HKCU (sin admin)
   - HKCU\Software\Classes\Directory\shell\<Key>
       (Default) = "Open with <Editor>"
       Icon      = "<ruta_al_exe>",0
       command\(Default) = "<ruta_al_launcher.cmd>" "%1"

   - HKCU\Software\Classes\Directory\Background\shell\<Key>
       (Default) = "Open with <Editor>"
       Icon      = "<ruta_al_exe>",0
       command\(Default) = "<ruta_al_launcher.cmd>" "%V"

   - Importante: %1 en el primero, %V en el segundo. NO uses --new-window;
     algunos forks de VS Code lo ignoran y rompen el IPC.

4. ACTIVAR EL MENÚ CLÁSICO DE WINDOWS 11
   - Crear HKCU\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}\InprocServer32
     con (Default) = "" (cadena vacía).
   - Esto hace que mi entrada custom (y todas las entradas de Registry de
     terceros) aparezcan en la primera pantalla en vez de quedar bajo
     "Mostrar más opciones". El menú nuevo de Win11 solo acepta extensiones
     MSIX con IExplorerCommand, así que esta es la única vía.

5. REINICIAR EL EXPLORADOR
   - Stop-Process -Name explorer -Force ; Start-Process explorer

6. VERIFICAR Y REPORTAR
   - Mostrame con `reg query` que las dos entradas quedaron bien.
   - Decime exactamente qué probar (click derecho sobre una carpeta nueva
     que NO esté ya abierta en el editor) y qué debería ver (la opción en
     la primera pantalla, breve flash de cmd al hacer click, editor abre
     con esa carpeta cargada).
   - Dame también el comando exacto para revertir todo si algún día quiero
     desinstalarlo.

Ejecutá todo en PowerShell. No uses archivos .reg sueltos. No me pidas
confirmación entre pasos. Si algo falla, mostrame el error real y proponé
el siguiente paso.

Pegá ese bloque en tu agente, completá las dos referencias entre <...> (nombre del editor y, opcionalmente, ruta si el agente no la encuentra solo) y dejalo trabajar. El proceso entero toma menos de 30 segundos en una máquina normal.

Principio: una receta técnica madura debe poder entregarse como prompt. Si el agente puede ejecutarla y verificarla sin tu intervención, la receta está completa; si no, todavía le falta detalle.

Checklist y reversión

Antes de cerrar la sesión, verificá:

• ✅ Click derecho sobre una carpeta nueva → ves "Open with <TuEditor>" en la primera pantalla.
• ✅ Click derecho sobre el fondo de una carpeta abierta → misma opción presente.
• ✅ Al hacer click, el editor abre con la carpeta cargada (puede aparecer un flash de cmd, es normal).
• ✅ No tenés que pasar por Mostrar más opciones.

Para revertir todo cuando ya no lo necesites:

# Ajustá $key al mismo valor que usaste arriba
$key = "MyEditor"

Remove-Item "HKCU:\Software\Classes\Directory\shell\$key" -Recurse -ErrorAction SilentlyContinue
Remove-Item "HKCU:\Software\Classes\Directory\Background\shell\$key" -Recurse -ErrorAction SilentlyContinue
Remove-Item "$env:USERPROFILE\${key}_launcher.cmd" -ErrorAction SilentlyContinue

# Solo si querés volver al menú nuevo de Win11
Remove-Item "HKCU:\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}" -Recurse -ErrorAction SilentlyContinue

Stop-Process -Name explorer -Force; Start-Process explorer

El conjunto entero — entradas de Registry, launcher, override del menú — vive en HKCU y en tu carpeta de usuario. No toca nada del sistema, no requiere admin, y se va sin dejar rastro cuando lo desinstalás. Ese es exactamente el tipo de personalización que vale la pena hacer: bajo costo, alto retorno diario, reversible en cinco segundos.