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.%1para el click sobre la carpeta,%Vpara 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 explorerTrade-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"
endlocalEl 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)
# -----------------------------------
$slug = $key.ToLower()
$launcher = "$env:USERPROFILE\${slug}_launcher.cmd"
$vbs = "$env:USERPROFILE\${slug}_launcher.vbs"
# 1) Launcher .cmd que limpia ELECTRON_RUN_AS_NODE y desacopla con `start`
@"
@echo off
setlocal
set ELECTRON_RUN_AS_NODE=
start `"`" `"$exe`" `"%~1`"
endlocal
"@ | Set-Content -Path $launcher -Encoding ASCII
# 2) Wrapper .vbs invisible — wscript.exe es headless, elimina el flash de cmd
@"
Set sh = CreateObject(`"WScript.Shell`")
folder = WScript.Arguments(0)
cmd = `"`"`"$launcher`"`" `"`"`" & folder & `"`"`"`"
sh.Run cmd, 0, False
"@ | Set-Content -Path $vbs -Encoding ASCII
# 3) Entrada para click sobre carpeta -> apunta al .vbs, no al .cmd
$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 "wscript.exe `"$vbs`" `"%1`""
# 4) 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 "wscript.exe `"$vbs`" `"%V`""
# 5) 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 ""
# 6) Reiniciar Explorer
Stop-Process -Name explorer -Force; Start-Process explorerProbalo con click derecho sobre cualquier carpeta. No vas a ver ningún flash de consola — la cadena wscript → .vbs → .cmd → editor es completamente headless. El editor abre directamente con la carpeta cargada, sin ventanas intermedias.
Editores nativos no necesitan el launcher .cmd
Esta receta usa un .cmd intermedio porque los editores Electron sufren de ELECTRON_RUN_AS_NODE. Los IDEs nativos (Sublime Text, Notepad++, los IntelliJ de JetBrains) no tienen ese problema y aceptan rutas directamente como argumento. Para ellos podés saltarte el .cmd pero el .vbs conviene mantenerlo igual para evitar cualquier flash:
# Para editores nativos, el .vbs invoca el .exe directamente
@"
Set sh = CreateObject(`"WScript.Shell`")
folder = WScript.Arguments(0)
sh.Run `"`"`"$exe`"`" `"`"`" & folder & `"`"`"`"`", 1, False
"@ | Set-Content -Path $vbs -Encoding ASCII
# (windowStyle=1 normal, porque para nativos sí queremos ver la ventana del editor)El override del menú clásico de Win11 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.>
Nombres canónicos a usar (NO los cambies entre ejecuciones):
- $key = nombre interno de la subclave de Registry, sin espacios
(ej. "VSCode", "Cursor", "Windsurf").
- $label = texto que aparece en el menú (ej. "Open with VS Code").
- $launcher = "%USERPROFILE%\${key_lowercase}_launcher.cmd"
REGLA IMPORTANTE — IDEMPOTENCIA:
Este prompt puede ejecutarse VARIAS veces en la misma máquina (porque
yo lo paso de nuevo, porque actualizo el editor, porque vos retomás
una sesión rota, o porque agrego DISTINTOS editores en momentos
distintos). Tu objetivo no es "agregar entradas" sino "dejar el
sistema en el estado correcto PARA ESTE EDITOR ESPECÍFICO":
- Si ya existe una instalación previa de este editor con el contenido
correcto: NO toques nada, solo verificá y reportá "ya estaba bien".
- Si ya existe una instalación previa de este editor con contenido
incorrecto o desactualizado (ruta vieja del .exe porque actualizó
el editor, launcher con el bug de --new-window, comando que apunta
directo al .exe sin pasar por launcher cuando el editor es Electron):
sobreescribí los valores in-place — no agregues una clave nueva.
- Si encontrás MÚLTIPLES claves para el MISMO editor con nombres
distintos (ej. "VSCode", "VS_Code", "VsCode" creadas en intentos
previos): borrá las extras y dejá solo la clave canónica con el
nombre $key que te di arriba.
- NO TOQUES entradas que pertenezcan a OTROS editores. Si ya existe
una clave "Cursor" y ahora estoy registrando "VSCode", la de Cursor
queda intacta.
- Identificá "instalaciones de este editor" matcheando: el (Default)
contiene el nombre del editor, O el command\(Default) referencia
el ejecutable del editor o un launcher con su slug.
Por favor hacé todo esto sin pedirme confirmación entre pasos:
PASO 0 — DIAGNÓSTICO PREVIO Y LIMPIEZA DE INSTALACIONES PARALELAS
- Enumerá todas las subclaves bajo:
HKCU:\Software\Classes\Directory\shell\
HKCU:\Software\Classes\Directory\Background\shell\
- Para cada subclave, leé su (Default) y su command\(Default).
- Marcá como "instalación de ESTE editor" cualquier subclave cuyo
(Default) o command apunte al editor que estoy registrando ahora
(matcheando por nombre del editor o por ruta a su .exe/launcher).
- Si hay subclaves marcadas con un nombre distinto al canónico
$key, BORRALAS recursivamente (Remove-Item -Recurse).
- Si la subclave canónica $key ya existe, NO la borres todavía
— la vas a actualizar in-place en el paso 3.
- Reportame qué encontraste y qué borraste antes de seguir. NO
toques claves de OTROS editores ni claves que no estén relacionadas.
PASO 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.
PASO 2 — ESCRIBIR EL LAUNCHER .CMD (idempotente: comparar antes)
- Path canónico: %USERPROFILE%\${key_lowercase}_launcher.cmd
- Contenido esperado (sustituyendo la ruta real al .exe detectada
en el paso 1):
@echo off
setlocal
set ELECTRON_RUN_AS_NODE=
start "" "<ruta_completa_al_editor.exe>" "%~1"
endlocal
- Si el archivo ya existe, COMPARÁ su contenido con el contenido
esperado. Si son idénticos, no escribas (evita marca de
modificación nueva). Si difieren — incluido el caso típico de
que el editor se actualizó y la ruta al .exe cambió —
sobreescribí.
- 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 — pero entonces NO crees el .cmd, y si existe uno de una
instalación anterior bórralo.
PASO 2b — ESCRIBIR EL WRAPPER VBSCRIPT INVISIBLE (idempotente)
- Path canónico: %USERPROFILE%\${key_lowercase}_launcher.vbs
- Por qué este wrapper: si el Registry invoca el .cmd directo,
aparece un flash de ventana negra de cmd.exe por ~200-300ms al
arrancar. wscript.exe (la engine de VBScript de Windows) es
headless por diseño y NO crea ventana de consola jamás. El .vbs
simplemente invoca al .cmd desde un proceso wscript, eliminando
el flash por completo.
- Contenido esperado del .vbs (3 líneas funcionales):
Set sh = CreateObject("WScript.Shell")
folder = WScript.Arguments(0)
cmd = """" & sh.ExpandEnvironmentStrings("%USERPROFILE%") & _
"\${key_lowercase}_launcher.cmd"" """ & folder & """"
sh.Run cmd, 0, False ' 0 = ventana oculta, False = no esperar
- Si el .vbs ya existe, comparar contenido y solo sobreescribir
si difiere.
- Para EDITORES NATIVOS (Sublime, Notepad++, JetBrains) que no
necesitan launcher .cmd, igual conviene usar un .vbs minimal
que invoque el .exe directo:
Set sh = CreateObject("WScript.Shell")
folder = WScript.Arguments(0)
sh.Run """<ruta_al_exe>"" """ & folder & """", 1, False
(windowStyle=1 normal, porque para editores nativos sí queremos
que se abra la ventana del editor).
PASO 3 — REGISTRAR/ACTUALIZAR LAS DOS ENTRADAS EN HKCU (idempotente)
- Clave canónica para click sobre carpeta:
HKCU\Software\Classes\Directory\shell\$key
(Default) = $label (ej. "Open with VS Code")
Icon = "<ruta_al_exe>",0
command\(Default) = wscript.exe "%USERPROFILE%\${key_lowercase}_launcher.vbs" "%1"
- Clave canónica para click en fondo de carpeta:
HKCU\Software\Classes\Directory\Background\shell\$key
(Default) = $label
Icon = "<ruta_al_exe>",0
command\(Default) = igual pero con "%V" en vez de "%1"
- Usá `New-Item -Force` y `Set-ItemProperty` — ambos son
idempotentes (sobreescriben si la clave/valor ya existe).
- Antes de dar por terminado el paso, leé los valores de vuelta
con `reg query` y verificá que matcheen lo esperado.
- IMPORTANTE: el comando del Registry apunta a `wscript.exe + .vbs`,
NO directo al .cmd ni al .exe. La cadena completa para editores
Electron es: wscript -> vbs -> cmd -> editor.exe. Si encontrás
una instalación previa que invocaba el .cmd directo desde el
Registry, ACTUALIZALA al patrón con wscript (esa versión vieja
generaba flash de consola — esta no).
- %1 en el primero, %V en el segundo. NO uses --new-window;
algunos forks de VS Code lo ignoran y rompen el IPC. Si existía
una instalación previa con --new-window, sacalo.
PASO 4 — ACTIVAR EL MENÚ CLÁSICO DE WINDOWS 11 (idempotente)
- Clave: HKCU\Software\Classes\CLSID\{86ca1aa0-34aa-4e8b-a509-50c905bae2a2}\InprocServer32
- Si ya existe con (Default) = "" (cadena vacía), no la toques
y reportá "menú clásico ya estaba activo".
- Si no existe o tiene otro valor, créala/sobreescribí con
(Default) = "" (cadena vacía).
- Esto saca TODAS las entradas custom de "Mostrar más opciones" y
las pone en la primera pantalla — no es exclusivo de este editor.
Recordame esa consecuencia explícitamente en el reporte final.
PASO 5 — REINICIAR EL EXPLORADOR (siempre)
- Stop-Process -Name explorer -Force; Start-Process explorer
- Es seguro hacerlo aunque no haya cambiado nada — toma 2 segundos
y garantiza que Explorer relea las claves.
PASO 6 — VERIFICACIÓN FINAL
- Confirmá que existe EXACTAMENTE UNA clave $key en cada uno
de los dos paths del menú contextual. Si por algún motivo
terminaste con duplicados, borralos.
- Mostrame con `reg query` los valores finales de las dos entradas
y del CLSID del menú clásico.
- Verificá que el launcher (si corresponde) existe y termina con
`endlocal`.
- Reportá un resumen explícito de qué hiciste:
a) ¿Era una instalación nueva, una actualización (qué cambió:
ruta del .exe, comando, etc.), o ya estaba todo bien y
solo verificaste?
b) Si limpiaste claves duplicadas/legacy de este mismo editor,
listá cuáles.
c) Versión del editor detectada (si podés sacarla del .exe).
- Decime exactamente qué probar: click derecho sobre una carpeta
nueva que NO esté ya abierta en el editor; debería aparecer la
opción en la primera pantalla, breve flash de cmd al hacer click,
editor abre con esa carpeta cargada.
- Dame el comando exacto para revertir todo si algún día quiero
desinstalarlo (incluyendo el caso de que querramos restaurar
el menú nuevo de Win11).
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. Re-ejecutar este prompt una segunda vez
sobre la misma máquina para el MISMO editor debe ser un no-op si todo
ya está correcto, y una corrección quirúrgica si algo se desvió.
Re-ejecutarlo para un editor DISTINTO debe agregar el nuevo editor
sin tocar las entradas de los editores ya instalados.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 — sin ningún flash de consola, todo invisible.
- ✅ 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"
$slug = $key.ToLower()
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\${slug}_launcher.cmd" -ErrorAction SilentlyContinue
Remove-Item "$env:USERPROFILE\${slug}_launcher.vbs" -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 explorerEl 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.