Você tenta fixar um programa na barra de tarefas do Windows 11, mas a opção simplesmente não aparece? O aplicativo abre normalmente, pode até ser fixado no Menu Iniciar, mas ao clicar com o botão direito não existe a opção “Fixar na barra de tarefas”.

Esse problema pode acontecer com determinados programas antigos, aplicativos portáteis ou softwares que possuem uma identificação diferente para o sistema de gerenciamento da barra de tarefas do Windows.

O mais curioso é que, em muitos casos, a barra de tarefas está funcionando normalmente. Outros aplicativos podem ser fixados sem dificuldade e apenas um programa específico apresenta o problema.

Neste tutorial vamos mostrar uma solução que pode ser utilizada com praticamente qualquer programa Win32 que apresente esse comportamento. A ideia é criar um novo atalho com um AppUserModelID próprio e informar explicitamente ao Windows que aquele atalho pode ser fixado na barra de tarefas.

Qual é o problema?

O cenário normalmente é parecido com este:

• o programa abre normalmente;
• o ícone aparece na barra enquanto o programa está aberto;
• outros aplicativos podem ser fixados normalmente;
• é possível encontrar o programa pelo Menu Iniciar;
• pode aparecer a opção Fixar em Iniciar;
• mas Fixar na barra de tarefas não aparece.

Nesse caso, reinstalar o Windows, apagar a barra de tarefas ou modificar políticas globais do sistema provavelmente não é a primeira coisa que você deve fazer.

Se o problema acontece apenas com um aplicativo, existe uma boa possibilidade de o próprio executável ou atalho estar sendo identificado de uma maneira que impede o pinning normal.

Por que alguns programas não podem ser fixados na barra?

O Windows utiliza várias informações para identificar um aplicativo e decidir como ele deve aparecer no Menu Iniciar e na barra de tarefas.

Entre essas informações existe o AppUserModelID, utilizado para fornecer uma identidade específica para determinado aplicativo.

Existem também propriedades capazes de modificar o comportamento de fixação, como:

• System.AppUserModel.ID;
• System.AppUserModel.PreventPinning;
• IsHostApp;
• NoStartPage.

Programas antigos, aplicações portáteis, launchers e alguns softwares que foram desenvolvidos antes das versões atuais do Windows podem apresentar uma integração incompleta com esses recursos.

Por isso, mesmo que o arquivo EXE funcione perfeitamente, o Windows pode não oferecer a opção para mantê-lo permanentemente na barra.

Antes de usar a solução, faça este teste

Primeiro tente fixar outro programa qualquer.

Por exemplo, abra o Bloco de Notas, clique com o botão direito no ícone dele na barra e verifique se aparece:

Fixar na barra de tarefas

Se a opção também não aparecer para outros programas, provavelmente existe um problema global no Windows e a solução deste artigo não é necessariamente a mais indicada.

Por outro lado, se todos os programas podem ser fixados normalmente e apenas um aplicativo específico não pode ser fixado, continue o tutorial.

Solução: criar um atalho com AppUserModelID próprio

A solução consiste em criar um novo arquivo .LNK para o aplicativo e adicionar duas propriedades:

System.AppUserModel.ID
System.AppUserModel.PreventPinning = False

Dessa forma, damos ao atalho uma identidade própria e informamos ao Windows que ele não deve ser impedido de ser fixado.

O procedimento utiliza PowerShell e não modifica os arquivos do programa.

1. Descubra o caminho completo do programa

Primeiro localize o arquivo EXE do aplicativo.

Exemplos:

C:\Program Files\MeuPrograma\MeuPrograma.exe

C:\Program Files (x86)\MeuPrograma\MeuPrograma.exe

D:\Programas\MeuPrograma\MeuPrograma.exe

Você vai precisar desse caminho no início do nosso script.

2. Abra o PowerShell como administrador

Abra o Menu Iniciar e procure:

PowerShell

Clique com o botão direito em Windows PowerShell e escolha:

Executar como administrador

Agora vamos criar o novo atalho.

3. Altere somente estas três informações

No código abaixo, preste atenção nas três primeiras variáveis:

$exe = "C:\CAMINHO\Programa.exe"
$nomeAtalho = "Meu Programa"
$appId = "MeuPrograma.Taskbar"

Você deve alterar somente essas informações de acordo com o programa que deseja fixar.

Por exemplo:

$exe = "D:\Programas\Editor\Editor.exe"
$nomeAtalho = "Meu Editor"
$appId = "MeuEditor.Taskbar"

4. Execute o script para corrigir o atalho

Copie todo o código abaixo para o PowerShell:

$exe = "C:\CAMINHO\Programa.exe"
$nomeAtalho = "Meu Programa"
$appId = "MeuPrograma.Taskbar"

$lnk = Join-Path ([Environment]::GetFolderPath("Programs")) "$nomeAtalho.lnk"

if (!(Test-Path $exe)) {
    Write-Host "ERRO: Executavel nao encontrado!" -ForegroundColor Red
    Write-Host $exe -ForegroundColor Yellow
    return
}

Remove-Item $lnk -Force -ErrorAction SilentlyContinue

if (-not ("TaskbarLinkFix" -as [type])) {

Add-Type -TypeDefinition @'
using System;
using System.Runtime.InteropServices;
using System.Text;

public class TaskbarLinkFix
{
    [ComImport]
    [Guid("00021401-0000-0000-C000-000000000046")]
    private class ShellLink { }

    [ComImport]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    [Guid("000214F9-0000-0000-C000-000000000046")]
    private interface IShellLinkW
    {
        void GetPath(
            [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszFile,
            int cch,
            IntPtr pfd,
            uint fFlags);

        void GetIDList(out IntPtr ppidl);
        void SetIDList(IntPtr pidl);

        void GetDescription(
            [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszName,
            int cch);

        void SetDescription(
            [MarshalAs(UnmanagedType.LPWStr)] string pszName);

        void GetWorkingDirectory(
            [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszDir,
            int cch);

        void SetWorkingDirectory(
            [MarshalAs(UnmanagedType.LPWStr)] string pszDir);

        void GetArguments(
            [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszArgs,
            int cch);

        void SetArguments(
            [MarshalAs(UnmanagedType.LPWStr)] string pszArgs);

        void GetHotkey(out short pwHotkey);
        void SetHotkey(short wHotkey);

        void GetShowCmd(out int piShowCmd);
        void SetShowCmd(int iShowCmd);

        void GetIconLocation(
            [Out, MarshalAs(UnmanagedType.LPWStr)] StringBuilder pszIconPath,
            int cch,
            out int piIcon);

        void SetIconLocation(
            [MarshalAs(UnmanagedType.LPWStr)] string pszIconPath,
            int iIcon);

        void SetRelativePath(
            [MarshalAs(UnmanagedType.LPWStr)] string pszPathRel,
            uint dwReserved);

        void Resolve(IntPtr hwnd, uint fFlags);

        void SetPath(
            [MarshalAs(UnmanagedType.LPWStr)] string pszFile);
    }

    [ComImport]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    [Guid("0000010B-0000-0000-C000-000000000046")]
    private interface IPersistFile
    {
        void GetClassID(out Guid pClassID);

        [PreserveSig]
        int IsDirty();

        void Load(
            [MarshalAs(UnmanagedType.LPWStr)] string pszFileName,
            uint dwMode);

        void Save(
            [MarshalAs(UnmanagedType.LPWStr)] string pszFileName,
            [MarshalAs(UnmanagedType.Bool)] bool fRemember);

        void SaveCompleted(
            [MarshalAs(UnmanagedType.LPWStr)] string pszFileName);

        void GetCurFile(
            [MarshalAs(UnmanagedType.LPWStr)] out string ppszFileName);
    }

    [StructLayout(LayoutKind.Sequential, Pack = 4)]
    private struct PROPERTYKEY
    {
        public Guid fmtid;
        public uint pid;

        public PROPERTYKEY(Guid guid, uint id)
        {
            fmtid = guid;
            pid = id;
        }
    }

    [StructLayout(LayoutKind.Explicit)]
    private struct PROPVARIANT
    {
        [FieldOffset(0)]
        public ushort vt;

        [FieldOffset(8)]
        public IntPtr ptr;

        [FieldOffset(8)]
        public short boolVal;

        public static PROPVARIANT FromString(string value)
        {
            PROPVARIANT pv = new PROPVARIANT();
            pv.vt = 31;
            pv.ptr = Marshal.StringToCoTaskMemUni(value);
            return pv;
        }

        public static PROPVARIANT FromBool(bool value)
        {
            PROPVARIANT pv = new PROPVARIANT();
            pv.vt = 11;
            pv.boolVal = value ? (short)-1 : (short)0;
            return pv;
        }

        public void Clear()
        {
            PropVariantClear(ref this);
        }

        [DllImport("ole32.dll")]
        private static extern int PropVariantClear(ref PROPVARIANT pvar);
    }

    [ComImport]
    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
    [Guid("886D8EEB-8CF2-4446-8D02-CDBA1DBDCF99")]
    private interface IPropertyStore
    {
        [PreserveSig]
        int GetCount(out uint cProps);

        [PreserveSig]
        int GetAt(uint iProp, out PROPERTYKEY pkey);

        [PreserveSig]
        int GetValue(ref PROPERTYKEY key, out PROPVARIANT pv);

        [PreserveSig]
        int SetValue(ref PROPERTYKEY key, ref PROPVARIANT pv);

        [PreserveSig]
        int Commit();
    }

    public static void Create(
        string exe,
        string shortcut,
        string appId)
    {
        IShellLinkW link = (IShellLinkW)new ShellLink();

        link.SetPath(exe);

        link.SetWorkingDirectory(
            System.IO.Path.GetDirectoryName(exe));

        link.SetDescription(
            System.IO.Path.GetFileNameWithoutExtension(exe));

        link.SetIconLocation(exe, 0);

        IPropertyStore store = (IPropertyStore)link;

        Guid appModelGuid =
            new Guid("9F4C2855-9F79-4B39-A8D0-E1D42DE1D5F3");

        PROPERTYKEY preventKey =
            new PROPERTYKEY(appModelGuid, 9);

        PROPVARIANT prevent =
            PROPVARIANT.FromBool(false);

        int hr = store.SetValue(
            ref preventKey,
            ref prevent);

        Marshal.ThrowExceptionForHR(hr);

        prevent.Clear();

        PROPERTYKEY idKey =
            new PROPERTYKEY(appModelGuid, 5);

        PROPVARIANT id =
            PROPVARIANT.FromString(appId);

        hr = store.SetValue(
            ref idKey,
            ref id);

        Marshal.ThrowExceptionForHR(hr);

        id.Clear();

        hr = store.Commit();

        Marshal.ThrowExceptionForHR(hr);

        ((IPersistFile)link).Save(shortcut, true);
    }
}
'@
}

[TaskbarLinkFix]::Create($exe, $lnk, $appId)

Write-Host ""
Write-Host "ATALHO CRIADO COM SUCESSO:" -ForegroundColor Green
Write-Host $lnk -ForegroundColor Yellow
Write-Host ""
Write-Host "AppUserModelID: $appId" -ForegroundColor Cyan

Stop-Process -Name explorer -Force
Start-Sleep -Seconds 2
Start-Process explorer.exe

5. Abra a pasta de atalhos do Menu Iniciar

Depois que o script terminar, pressione:

Windows + R

Digite:

shell:Programs

Pressione Enter.

O Windows abrirá a pasta onde ficam os atalhos de programas do seu usuário.

Você deverá encontrar o novo atalho criado pelo script.

6. Agora fixe o novo atalho na barra de tarefas

Clique com o botão direito sobre o novo atalho.

No Windows 11, talvez seja necessário selecionar:

Mostrar mais opções

Agora procure:

Fixar na barra de tarefas

Em situações nas quais o programa anteriormente não oferecia essa opção, o novo atalho pode passar a ser reconhecido corretamente pelo Windows.

O que o script modifica?

Apesar de o código ser relativamente grande, ele executa uma tarefa bastante específica.

Ele cria um atalho tradicional do Windows e adiciona duas propriedades ao arquivo:

System.AppUserModel.ID = identidade personalizada

System.AppUserModel.PreventPinning = False

O primeiro parâmetro fornece uma identidade explícita ao aplicativo.

O segundo informa que o atalho não deve impedir sua fixação.

Depois disso, o novo arquivo .LNK é salvo dentro do Menu Iniciar.

O script altera o programa original?

Não.

O executável original continua no mesmo lugar e não é modificado.

O código também não precisa substituir DLLs, alterar arquivos internos do programa ou instalar componentes dentro da aplicação.

Ele cria apenas um novo atalho contendo propriedades adicionais utilizadas pelo Windows.

Serve para qualquer programa?

A técnica pode funcionar com muitos programas tradicionais de desktop, especialmente aplicativos Win32.

Ela pode ser útil principalmente quando:

• o programa é antigo;
• o aplicativo é portátil;
• o software não possui instalador moderno;
• o programa foi copiado de outro computador;
• o executável abre normalmente, mas não pode ser fixado;
• o Windows não cria corretamente a identidade do aplicativo;
• apenas aquele programa apresenta o problema.

Isso não significa que o método resolverá absolutamente todos os casos.

Aplicativos Microsoft Store, aplicações empacotadas, programas que utilizam launchers ou softwares com políticas específicas podem utilizar outro sistema de identificação.

Se nenhum programa puder ser fixado

Existe uma situação diferente que merece atenção.

Se a opção Fixar na barra de tarefas desapareceu de praticamente todos os seus programas, então provavelmente você não está diante de um problema específico do aplicativo.

Nesse caso, vale verificar:

• políticas do Windows;
• configurações corporativas;
• alterações no Registro;
• programas de personalização da barra;
• ferramentas de otimização;
• problemas no Windows Explorer.

A solução deste artigo foi pensada principalmente para o cenário no qual outros aplicativos podem ser fixados normalmente, mas um programa específico não apresenta a opção.

Por que não basta criar um atalho comum?

Em alguns casos, criar um simples atalho para o EXE e colocá-lo no Menu Iniciar já resolve.

Você pode tentar isso antes do procedimento avançado.

Entretanto, alguns programas continuam sem oferecer a opção de fixação mesmo depois da criação de um novo .LNK.

É justamente nesses casos que configurar explicitamente o AppUserModelID pode fazer diferença.

Cuidados antes de executar

Utilize sempre o caminho do executável original de um programa que você conhece e confia.

Não utilize este procedimento para executar arquivos desconhecidos baixados da internet.

Também confira cuidadosamente a variável:

$exe = "C:\CAMINHO\Programa.exe"

Se o caminho estiver incorreto, o próprio script deverá informar que o executável não foi encontrado.

Conclusão

Quando Fixar na barra de tarefas não aparece no Windows 11, nem sempre significa que existe algum problema grave na barra de tarefas.

Se outros aplicativos continuam oferecendo essa opção normalmente, o problema pode estar relacionado à maneira como aquele programa específico está sendo identificado pelo Windows.

Criar um novo atalho com um AppUserModelID explícito e definir PreventPinning como falso pode fazer com que o sistema volte a reconhecer aquele aplicativo como elegível para ser fixado.

O melhor dessa solução é que não precisamos modificar o executável original nem reinstalar o programa.

Depois de criar o novo atalho, basta abrir shell:Programs, localizar o aplicativo e utilizar novamente a opção Fixar na barra de tarefas.

Se este método resolveu aquele programa antigo ou portátil que se recusava a permanecer na barra, compartilhe este tutorial. É um problema bastante específico e, quando acontece, pode ser difícil descobrir por que apenas aquele aplicativo não oferece a opção que existe normalmente em todos os outros.