Crea accesos directos personalizados con Windows Script Host

Crear accesos directos no es solo un gesto de comodidad: es una forma de automatizar tareas y mejorar la productividad día a día en Windows. Windows Script Host (WSH) ofrece una vía sencilla y potente para generar enlaces a aplicaciones, documentos y direcciones web desde múltiples lenguajes de scripting.

En esta guía práctica reunimos técnicas probadas con VBScript, PowerShell, Visual Basic, Visual FoxPro y escenarios modernos con paquetes MSIX y PSF. El objetivo es que puedas elegir el enfoque que mejor encaje con tu entorno (usuario final, IT, Intune/SCCM o empaquetado), y que lo apliques con garantías.

Qué es Windows Script Host y por qué te interesa

Windows Script Host es la infraestructura que permite ejecutar VBScript y JScript de forma nativa en Windows, además de exponer un modelo de objetos COM para automatizar tareas del sistema. El objeto WScript.Shell es la pieza clave para crear accesos directos de escritorio, del menú Inicio o de carpetas especiales.

WSH forma parte de Windows desde versiones como Windows 98 y 2000, y se puede añadir en ediciones antiguas como Windows NT 4.0 mediante componentes opcionales. En los sistemas modernos viene integrado y, en la práctica, basta con contar con los ejecutables wscript.exe y cscript.exe para lanzar scripts.

Requisitos y buenas prácticas antes de empezar

Antes de ponerte manos a la obra conviene revisar algunos puntos básicos. Verifica que WSH está disponible y que no hay políticas que bloqueen la ejecución de scripts. En entornos corporativos, las GPO y la configuración de antivirus pueden afectar a VBScript o a PowerShell.

Evita llenar el escritorio con accesos directos. Solo crea accesos cuando aporten valor y, si los distribuyes de forma centralizada, define un criterio claro (p. ej., carpetas de trabajo o apps corporativas críticas).

Si el script se ejecuta como SYSTEM o en contexto de máquina (Intune/SCCM), piensa bien dónde escribirás el .lnk: quizá te convenga el escritorio público (C:\\Users\\Public\\Desktop) en lugar del escritorio del usuario actual.

Comprueba la ruta del destino, permisos y variables de entorno. Un error típico es apuntar a rutas con versiones cambiantes (Program Files\\WindowsApps) o usar UNC sin acceso de la cuenta que ejecuta el script.

Carpetas especiales y cómo resolver sus rutas

WSH resuelve nombres de carpetas especiales a su ruta real mediante WshShell.SpecialFolders. Entre las más útiles están Desktop, StartMenu, Programs, Startup o Favorites, además de sus variantes para todos los usuarios (AllUsersDesktop, AllUsersStartMenu, etc.). Esto te permite ser independiente del idioma y de la estructura exacta del perfil.

Si trabajas con Visual Basic clásico o deseas obtener rutas desde API, puedes recurrir a SHGetSpecialFolderLocation/SHGetPathFromIDList para enumerar rutas como Escritorio, Programas o Documentos recientes. Es útil cuando integras en aplicaciones que no dependen directamente del objeto WScript.

Patrón básico: crear accesos directos con WScript.Shell

El flujo es sencillo: creas la instancia COM, generas el acceso directo, rellenas propiedades y guardas. Este patrón se repite en VBScript, VBA, VB6, VFP y PowerShell con pequeñas variaciones de sintaxis.

' VBScript: acceso directo a una aplicación
Dim sh, lnk
Set sh = CreateObject("WScript.Shell")
Dim escritorio: escritorio = sh.SpecialFolders("Desktop")
Set lnk = sh.CreateShortcut(escritorio & "\\MiApp.lnk")
lnk.TargetPath = "%windir%\\notepad.exe"
lnk.IconLocation = "%windir%\\system32\\shell32.dll,0"
lnk.Arguments = ""
lnk.WorkingDirectory = "%windir%"
lnk.WindowStyle = 4 ' Normal (3 maximizada, 7 minimizada)
lnk.Save

En VBA/VB6 el patrón es equivalente, solo cambia la sintaxis y dónde alojas el código. Puedes crear el acceso en el escritorio, asignar descripción, icono, tecla rápida (Hotkey) y estilo de ventana:

' VBA/VB6: crear acceso con icono y hotkey
Dim sh As Object, sc As Object
Set sh = CreateObject("WScript.Shell")
Dim destino As String: destino = sh.SpecialFolders("Desktop") & "\\BlocDeNotas.lnk"
Set sc = sh.CreateShortcut(destino)
With sc
  .TargetPath = "%windir%\\system32\\notepad.exe"
  .WorkingDirectory = "%windir%\\system32"
  .IconLocation = "%windir%\\system32\\shell32.dll,2"
  .Description = "Abrir el Bloc de notas"
  .Hotkey = "ALT+CTRL+N"
  .WindowStyle = 4
  .Save
End With

Con Visual FoxPro también puedes usar el objeto WScript.Shell. La idea es idéntica: localizar Desktop, crear el .lnk y establecer propiedades como WindowStyle, IconLocation, TargetPath o la combinación de teclas.

* Visual FoxPro: crear acceso directo de ejemplo
LOCAL sh, desk, sc
sh = CREATEOBJECT("WScript.Shell")
desk = sh.SpecialFolders("Desktop")
sc = sh.CreateShortcut(desk + "\\EjemploWSH.lnk")
sc.TargetPath = "%windir%\\notepad.exe"
sc.IconLocation = "C:\\Path\\a\\miicono.ico"
sc.Hotkey = "ALT+CTRL+F"
sc.WindowStyle = 3 && 3=max 7=min 4=normal
sc.Save

En todos los casos, el núcleo es el mismo: CreateShortcut, TargetPath, Save. A partir de ahí, personaliza argumentos, icono, directorio de trabajo y estilo de ventana según necesites.

Argumentos, estilo de ventana, iconos y teclas rápidas

Cuando el acceso debe lanzar una app con parámetros, basta con rellenar .Arguments. Para que el proceso arranque en una carpeta concreta, usa .WorkingDirectory con la ruta adecuada.

Para el aspecto, define .IconLocation apuntando a un .ico o a un recurso en un .exe/.dll (puedes indicar índice tras la coma). El comportamiento al abrir se controla con .WindowStyle: 3 maximizada, 7 minimizada, 4 normal.

Si quieres una combinación de teclas, usa .Hotkey con el patrón ALT+CTRL+Letra (por ejemplo, ALT+CTRL+N). Esta asignación acelera la apertura, pero no es recomendable asignar demasiadas para no interferir con atajos del sistema.

Accesos directos de tipo URL (.url)

Además de .lnk de aplicaciones, WSH puede crear accesos .url que abre el navegador predeterminado. El TargetPath apunta a la dirección web y, si necesitas un icono propio, puedes editar después el archivo .url para añadir IconFile e IconIndex.

' VBScript: acceso directo a una URL
Dim sh, urlShortcut
Set sh = CreateObject("WScript.Shell")
Dim desk: desk = sh.SpecialFolders("Desktop")
Set urlShortcut = sh.CreateShortcut(desk & "\\SitioCorporativo.url")
urlShortcut.TargetPath = "https://www.ejemplo.com"
urlShortcut.Save
' (Opcional) reabrir el .url como texto y añadir:
' IconFile=C:\\Rutas\\icono.ico
' IconIndex=0

Este enfoque resulta ideal para enlaces a SharePoint, intranet o aplicaciones web que quieras dejar a mano en el escritorio del usuario.

PowerShell para IT: Intune, SCCM y despliegues a escala

PowerShell incorpora acceso al mismo modelo COM de WSH, por lo que puedes crear accesos y distribuirlos masivamente. Lo habitual es detectar el escritorio correcto (usuario o público), generar carpetas de destino y, si hace falta, anclar rutas en Acceso rápido.

# PowerShell: utilidades y creación del acceso
param(
  [Parameter(Mandatory=$true)] [string]$ShortcutTargetPath,
  [Parameter(Mandatory=$true)] [string]$ShortcutDisplayName,
  [string]$IconFile = $null,
  [string]$ShortcutArguments = $null,
  [string]$WorkingDirectory = $null
)
function Test-RunningAsSystem {
  # Devuelve true si el contexto es SYSTEM (S-1-5-18)
  ((whoami -user) -match "S-1-5-18")
}
function Get-DesktopDir {
  if (Test-RunningAsSystem) {
    Join-Path $env:PUBLIC "Desktop"
  } else {
    [Environment]::GetFolderPath("Desktop")
  }
}
function New-Shortcut {
  param([string]$Target, [string]$Path, [string]$Args, [string]$Work, [string]$Icon)
  $sh = New-Object -ComObject WScript.Shell
  $lnk = $sh.CreateShortcut($Path)
  $lnk.TargetPath = $Target
  if ($Args) { $lnk.Arguments = $Args }
  if ($Work) { $lnk.WorkingDirectory = $Work }
  if ($Icon) { $lnk.IconLocation = $Icon }
  $lnk.WindowStyle = 4
  $lnk.Save()
  [Runtime.InteropServices.Marshal]::ReleaseComObject($sh) | Out-Null
}
$desk = Get-DesktopDir
$targetFolder = Join-Path $desk "SharePoint Shortcuts"
if (-not (Test-Path $targetFolder)) { New-Item -ItemType Directory -Path $targetFolder | Out-Null }
$dest = Join-Path $targetFolder ("{0}.lnk" -f $ShortcutDisplayName)
New-Shortcut -Target $ShortcutTargetPath -Path $dest -Args $ShortcutArguments -Work $WorkingDirectory -Icon $IconFile

En implementaciones con Intune, este patrón permite crear una carpeta en el escritorio y depositar accesos a Edge con parámetros como una URL de SharePoint. Si se ejecuta como SYSTEM, el escritorio objetivo será el público, visible para todos los perfiles.

En SCCM, si prefieres desplegar un .lnk ya preparado, la orden mínima puede ser tan simple como copiarlo al escritorio público: Copy-Item \\servidor\\ruta\\acceso.lnk C:\\Users\\Public\\Desktop. Si no aparece, revisa estos puntos:

• Contexto de ejecución: asegúrate de que el programa corre con suficientes permisos y en el usuario/sistema esperado.
• Acceso al recurso compartido: la cuenta de ejecución debe poder leer la ruta UNC.
• Rutas con espacios: encierra -Path y -Destination entre comillas.
• Bitness: en entornos mixtos 32/64 bits, confirma que no hay redirecciones indeseadas.

Anclar a Acceso rápido con Shell.Application

Además del escritorio, puedes anclar carpetas a Acceso rápido con el objeto COM Shell.Application. Es útil cuando creas una ruta de enlaces y quieres que quede accesible en el Explorador.

# PowerShell: anclar carpeta a Acceso rápido
$quick = New-Object -ComObject shell.application
$toPin = Join-Path ([Environment]::GetFolderPath("Desktop")) "SharePoint Shortcuts"
$home = "shell:::{679f85cb-0220-4080-b29b-5540cc05aab6}"
if(-not ($quick.Namespace($home).Items() | Where-Object { $_.Path -eq $toPin })){
  $quick.Namespace($toPin).Self.InvokeVerb("pintohome")
}

Si administras equipos y quieres que los usuarios localicen rápido sus accesos, esta pequeña acción marca la diferencia en su día a día.

MSIX y PSF: crear un acceso sin depender de rutas con versión

Cuando empaquetas aplicaciones con MSIX, la ruta de instalación incluye la versión (por ejemplo, C:\\Program Files\\WindowsApps\\MiApp_1.0.0.0_x86__…). Cambia con cada actualización, así que es mala idea fijar un .lnk con esa ruta. Solución: AppExecutionAlias. Definiendo un alias en el manifiesto, puedes lanzar la app con %localappdata%\\Microsoft\\WindowsApps\\miapp.exe sin atarte a la versión.

Para ello, añade los espacios de nombres en el manifiesto (uap3 y desktop) y crea la extensión windows.appExecutionAlias apuntando al ejecutable del paquete. Recuerda incluir los nombres en IgnorableNamespaces para que el manifiesto los reconozca.

Después, puedes cambiar el punto de entrada de la aplicación a PSFLauncher32.exe/PSFLauncher64.exe (según arquitectura) y delegar la creación del acceso en un script de inicio definido en config.json mediante PSF. El script se ejecuta una vez en la primera inicialización.

{
  "applications": [
    {
      "id": "App",
      "executable": "MiApp\\MiApp.exe",
      "workingDirectory": "MiApp\\",
      "startScript": {
        "scriptPath": "createshortcut.ps1",
        "runInVirtualEnvironment": false,
        "waitForScriptToFinish": true,
        "showWindow": false,
        "runOnce": true
      }
    }
  ]
}

El PowerShell createshortcut.ps1 puede copiar al escritorio del usuario un .lnk ya preparado dentro del paquete y, además, llevar un icono al área de LocalCache\\Roaming que permanece estable entre versiones.

# createshortcut.ps1 (dentro del paquete)
Copy-Item "Mi App.lnk" "$env:USERPROFILE\\Desktop\\Mi App.lnk" -Force
Copy-Item "miapp.ico" "$env:APPDATA\\miapp.ico" -Force

Con este enfoque te aseguras de que el acceso funcione tras una actualización, sin tocar el .lnk en cada versión. Si el acceso apunta al alias (por ejemplo, %localappdata%\\Microsoft\\WindowsApps\\miapp.exe), la ruta seguirá siendo válida.

Control de errores y validaciones recomendadas

Antes de generar el .lnk conviene validar que el TargetPath existe (salvo que uses variables como %windir% o alias). En VBA/VB6 puedes alertar si el ejecutable no está o cancelar la operación; en PowerShell, comprueba con Test-Path si la ruta es accesible.

Si la ruta del icono es un .ico en red, una táctica útil es copiarlo a la carpeta temporal o a APPDATA del usuario, y referenciarlo desde ahí. Así evitas iconos rotos si el recurso de red no está disponible.

Cuando edites accesos .url, si necesitas icono propio, vuelve a abrir el archivo como texto y añade IconFile e IconIndex al final. Esto te da control total sobre su aspecto sin depender del navegador.

Al terminar con COM, libera objetos con ReleaseComObject en PowerShell, o asigna Nothing en VB/VBA. Es un detalle menor, pero ayuda a evitar recursos colgados en ejecuciones intensivas.

Casos típicos que fallan y cómo resolverlos

Si un despliegue por SCCM finaliza con código 0 pero el acceso no aparece, revisa primero el usuario objetivo del escritorio. Si corría como SYSTEM y escribes en %USERPROFILE%\\Desktop, no verás nada en el perfil interactivo. Usa C:\\Users\\Public\\Desktop para hacerlo visible a todos.

En Intune, cuando generes accesos para Edge con argumentos (por ejemplo, una URL con espacios codificados), confirma que las comillas están bien en -ShortcutArguments y que el texto llega intacto. Un solo espacio fuera de sitio puede romper el destino del .lnk.

Para carpetas corporativas de enlaces (p. ej., «SharePoint Shortcuts»), crea primero la carpeta en el escritorio correcto y, si quieres destacarla en el Explorador, ancla a Acceso rápido como hemos visto con Shell.Application.

Si distribuyes el .lnk ya construido en un paquete MSIX que se actualiza, no lo apuntes a la ruta con versión dentro de WindowsApps. Usa AppExecutionAlias y copia el icono fuera de la carpeta versionada.

Trucos útiles con variables y rutas

Para escribir scripts portables, apóyate en variables de entorno: %windir%, %systemroot%, %ProgramFiles% y similares. En WSH puedes expandirlas con ExpandEnvironmentStrings, y en PowerShell puedes referirte a ellas vía $env:VARIABLE.

Cuando construyas rutas dinámicas, comprueba si la carpeta de trabajo termina en \ para no duplicar barras ni romper el TargetPath al concatenar. Es un pequeño guardarraíl que evita errores sutiles en producción.

Para accesos que requieren parámetros complejos, considera escribir un pequeño script .cmd o .ps1 y que el acceso apunte a él. Así simplificas el .lnk y controlas mejor el quoting y el orden de argumentos.

Si necesitas teclas rápidas, intenta reservar combinaciones con letras significativas y evita choques con atajos comunes. En entornos con muchas apps, documenta los atajos para que el usuario saque partido sin ensayo y error.

Tienes un abanico de opciones para crear accesos en Windows de forma fiable y flexible. WSH es la base común, y encima puedes elegir la capa: scripts clásicos, PowerShell moderno o empaquetado MSIX con PSF cuando buscas procesos repetibles a escala. La clave está en seleccionar la ruta adecuada, validar el contexto de ejecución y no atarte a rutas frágiles con versión.