O Paint.NET, um editor de imagens popular para Windows, agora pode rodar no Linux em uma configuração experimental bem inicial.

O Paint.NET é um aplicativo Windows desde 2004. Durante muitos anos, rodá-lo no Linux por meio do Wine era difícil porque o Paint.NET depende fortemente de tecnologias gráficas do Windows, principalmente Direct2D.

O Wine tem algum suporte a Direct2D, mas não era completo o suficiente para o Paint.NET funcionar corretamente.

Para resolver esse problema, o criador do Paint.NET, Rick Brewster, adotou uma abordagem incomum. Em vez de gastar anos construindo manualmente a tecnologia que faltava, ele usou o assistente de codificação por IA Claude para criar uma nova implementação de Direct2D específica para o Paint.NET.

Segundo Brewster, o Claude ajudou a produzir cerca de 180 mil linhas de código em aproximadamente três semanas.

O resultado não é uma versão nativa do Paint.NET para Linux. Continua sendo o aplicativo Windows rodando por meio do Wine, mas com uma nova implementação gráfica projetada para contornar as limitações do Wine.

Usando Claude AI no desenvolvimento de software

Brewster descreve grande parte desse processo de desenvolvimento como "vibe coding".

Em termos simples, isso significa que ele não inspecionou manualmente cada linha da grande quantidade de código gerado por IA. Em vez disso, ele dependeu muito de compilar o software, executar testes, verificar resultados, encontrar problemas e pedir que a IA corrigisse ou melhorasse o código.

No entanto, isso não significa que o desenvolvedor simplesmente pediu à IA para escrever o programa e não fez mais nada.

Brewster testou a implementação, investigou problemas, comparou resultados e corrigiu erros importantes. O código gerado por IA também passou por várias rodadas de teste e melhoria.

O que chama atenção é a escala: um componente gráfico muito grande foi produzido em pouco tempo com ajuda substancial de um agente de codificação por IA.

Reação da comunidade

Há três razões importantes pelas quais esse experimento atraiu atenção.

1. O Paint.NET no Linux preenche um meio-termo útil

O Linux já tem editores de imagem poderosos, como GIMP e Krita. No entanto, alguns usuários acham esses aplicativos mais complicados do que precisam.

No outro extremo, existem programas de pintura muito simples.

O Paint.NET fica entre esses dois grupos. Ele oferece ferramentas familiares, como camadas, transparência, seleções, efeitos e recursos simples de desenho, sem tentar ser um pacote gráfico profissional completo.

Para alguns usuários de Linux, isso torna o Paint.NET uma alternativa atraente.

2. A IA pode mudar o que um único desenvolvedor consegue construir

O experimento mostra como um assistente de codificação por IA pode ajudar um desenvolvedor individual a enfrentar um problema tecnicamente difícil.

Implementar uma API gráfica grande normalmente é um projeto de engenharia importante. Aqui, um assistente de IA foi usado para gerar uma grande quantidade de código e para ajudar com testes e depuração.

Isso não prova que a IA pode substituir uma equipe de engenharia. Mostra que o desenvolvimento assistido por IA pode permitir que uma equipe pequena — ou até um único desenvolvedor — tente projetos que antes exigiriam muito mais tempo de engenharia.

3. Isso levanta uma questão jurídica e técnica incomum

O projeto também gerou discussão sobre desenvolvimento clean-room e código gerado por IA.

O Wine tradicionalmente segue regras rígidas sobre como o código de compatibilidade com Windows é desenvolvido. Código derivado das implementações proprietárias da Microsoft ou de engenharia reversa pode criar problemas para o projeto.

A IA introduz uma questão nova: o código gerado por um modelo de IA pode ser considerado código clean-room se ninguém puder verificar completamente com qual material o modelo foi treinado?

Alguns desenvolvedores do Wine discutiram essa questão.

No entanto, é importante não exagerar a situação. Atualmente não há evidências de que o Claude tenha copiado o código-fonte da Microsoft para este projeto. A preocupação é com a procedência desconhecida do código gerado por IA e se esse código atende aos requisitos de desenvolvimento do Wine.

Portanto, esta é uma questão técnica e jurídica genuína, não uma prova de que o projeto Paint.NET violou os direitos autorais da Microsoft.

Quatro coisas para saber antes de testar o Paint.NET no Linux

Se você quiser experimentar o Paint.NET no Linux, há várias limitações importantes.

1. Espere lentidão e instabilidade

Este é um experimento extremamente inicial.

Não foi feito para uso diário normal e não é oficialmente suportado como uma versão Linux estável.

Brewster descreveu a situação atual com a frase humorística:

"It doesn't not work."

Em outras palavras, o Paint.NET até roda, mas muitas coisas ainda podem dar errado.

O Wine também ainda tem recursos do Windows ausentes ou incompletos que o Paint.NET espera. A nova implementação gráfica, por sua vez, ainda não passou pelos testes de longo prazo que um motor gráfico de produção maduro normalmente receberia.

2. Use a versão portátil

O instalador normal do Paint.NET para Windows não funciona corretamente nesta configuração experimental do Wine.

Você deve usar a versão portátil do Paint.NET 5.2 Alpha.

As instruções experimentais oficiais também exigem Wine 11.14 ou mais novo.

3. Você precisa de configuração gráfica adicional

O experimento usa DXVK, que traduz comandos gráficos Direct3D em comandos Vulkan.

Você também precisa de uma biblioteca d3dcompiler_47 nativa em vez da versão embutida do Wine.

As instruções de configuração usam:

winetricks d3dcompiler_47 dxvk

Seu driver gráfico também precisa suportar a versão do Vulkan exigida pela versão escolhida do DXVK.

Em particular, o DXVK 3.x exige Vulkan 1.4, enquanto versões mais antigas do DXVK 2.7.x funcionam com Vulkan 1.3.

Portanto, se o seu sistema só suporta Vul 1.3, você pode precisar usar uma versão mais antiga do DXVK, como 2.7.1.

4. Você deve iniciar o Paint.NET com /wine

Você não pode simplesmente iniciar o programa normalmente.

A versão experimental precisa ser iniciada com a opção de linha de comando /wine:

wine PaintDotNet.exe /wine

Isso informa ao Paint.NET que ele está rodando no Wine e ativa um comportamento especial de compatibilidade.

Entre outras coisas, isso permite que o programa evite recursos de desktop do Windows que não funcionam corretamente no Wine e use a nova implementação gráfica.

Instalando o Paint.NET 5.2 Alpha no Ubuntu 26.04

A configuração experimental foi testada com sucesso no Ubuntu 26.04 LTS Desktop usando:

  • Ubuntu 26.04 LTS desktop, versão de 64 bits
  • Wine 11.16 Staging
  • Um prefixo Wine dedicado
  • Winetricks
  • DXVK
  • d3dcompiler_47 nativo
  • Paint.NET 5.200.9739.41506
  • Build portátil x64

O aplicativo foi iniciado com sucesso e exibiu a interface gráfica do Paint.NET.

Isso confirma que a implementação experimental Paint.NET/Wine pode rodar em uma versão LTS atual do Ubuntu.

Se você quiser testar o Paint.NET no Ubuntu, siga os passos abaixo.

Passo 1: Ative o suporte a pacotes de 32 bits

Abra um terminal e execute:

sudo dpkg --add-architecture i386
sudo apt update

Passo 2: Instale os pré-requisitos do WineHQ

sudo apt install wget gnupg2 software-properties-common

Passo 3: Adicione o repositório WineHQ

Crie o diretório do chaveiro:

sudo mkdir -pm755 /etc/apt/keyrings

Baixe e instale a chave de assinatura do WineHQ:

wget -qO- https://dl.winehq.org/wine-builds/winehq.key \
| gpg --dearmor \
| sudo tee /etc/apt/keyrings/winehq-archive.key > /dev/null

Adicione o repositório WineHQ do Ubuntu 26.04 resolute:

sudo wget -NP /etc/apt/sources.list.d/ \
https://dl.winehq.org/wine-builds/ubuntu/dists/resolute/winehq-resolute.sources

Atualize as listas de pacotes:

sudo apt update

Passo 4: Instale o Wine Staging

O pacote Wine padrão do Ubuntu é antigo demais para o suporte experimental do Paint.NET no Linux. O Ubuntu 26.04 atualmente fornece Wine 10.0 nos repositórios padrão, enquanto o Paint.NET 5.2 Alpha exige Wine 11.14 ou mais novo. Por isso, usamos a versão WineHQ Staging, que fornece um build do Wine recente o suficiente.

Instale o Wine Staging:

sudo apt install --install-recommends winehq-staging

Verifique a versão instalada:

wine --version

A instalação testada relatou:

wine-11.16 (Staging)

O requisito importante para este experimento do Paint.NET é Wine 11.14 ou mais novo.

Passo 5: Crie um prefixo Wine dedicado

É recomendado manter o Paint.NET no próprio ambiente Wine, em vez de misturá-lo com outros aplicativos Windows.

Execute:

export WINEPREFIX="$HOME/.wine-paintnet"
export WINEARCH=win64
wineboot -u

Em seguida, inicialize a configuração do Wine:

winecfg

Se a janela de configuração do Wine abrir corretamente, você está pronto para continuar. Feche a janela e siga os passos abaixo.

Importante:

Ao abrir um novo terminal mais tarde, lembre-se de definir o prefixo novamente:

export WINEPREFIX="$HOME/.wine-paintnet"

WINEARCH=win64 é necessário na criação do prefixo; normalmente não precisa ser definido novamente depois.

Passo 6: Instale o Winetricks

Verifique se o Winetricks já está instalado:

winetricks --version

Se não estiver instalado:

sudo apt install winetricks

O sistema testado usou a versão:

20250102

Passo 7: Instale DXVK e d3dcompiler_47

Certifique-se de que o prefixo Wine dedicado do Paint.NET esteja selecionado:

export WINEPREFIX="$HOME/.wine-paintnet"

Em seguida, execute:

winetricks d3dcompiler_47 dxvk

Permita que o Winetricks conclua a instalação.

Passo 8: Verifique as substituições de DLL

Execute:

wine reg query "HKCU\Software\Wine\DllOverrides"

As entradas relevantes devem mostrar native.

A configuração testada continha:

*d3d10core          REG_SZ    native
*d3d11              REG_SZ    native
*d3d8               REG_SZ    native
*d3d9               REG_SZ    native
*d3dcompiler_47     REG_SZ    native
*dxgi               REG_SZ    native

Em particular, certifique-se de que isto esteja presente:

*d3dcompiler_47     REG_SZ    native

Se essas substituições estiverem ausentes, não prossiga ainda para a solução de problemas do Paint.NET. Corrija primeiro a configuração do Wine/DXVK.

Passo 9: Verifique o Vulkan

Instale as ferramentas de diagnóstico do Vulkan:

sudo apt install vulkan-tools

Em seguida, execute:

vulkaninfo --summary

Você precisa de suporte Vulkan funcional para o DXVK.

O dispositivo Vulkan exato vai depender do seu hardware e da sua configuração gráfica.

Por exemplo, um sistema pode reportar uma GPU física Intel, AMD ou NVIDIA.

Implementações Vulkan por software, como llvmpipe, também podem fornecer Vulkan, mas o desempenho tende a ser substancialmente pior, porque a renderização é feita pela CPU.

Passo 10: Baixe o Paint.NET 5.2 Alpha

Baixe a versão portátil x64 do Paint.NET 5.2 Alpha na página de releases do Paint.NET no GitHub.

Não use o instalador normal do Windows.

O build testado foi: paint.net.5.200.9739.41506.portable.x64.zip.

Crie um diretório para o Paint.NET:

mkdir -p ~/PaintDotNet

Entre no diretório e baixe o arquivo ZIP:

cd ~/PaintDotNet
wget https://github.com/paintdotnet/release/releases/download/v5.2-alpha.5.200.9739.41506/paint.net.5.200.9739.41506.portable.x64.zip

Extraia o arquivo:

unzip paint.net.5.200.9739.41506.portable.x64.zip

Se o unzip não estiver instalado:

sudo apt install unzip

Após a extração, o diretório que contém o aplicativo deve conter:

paintdotnet.exe

além das DLLs do Paint.NET e dos demais arquivos de runtime.

Passo 11: Inicie o Paint.NET

Certifique-se de que o prefixo Wine dedicado esteja selecionado:

export WINEPREFIX="$HOME/.wine-paintnet"

Certifique-se de continuar no diretório do Paint.NET. Se não estiver, entre nele com cd:

cd ~/PaintDotNet

Inicie o aplicativo Paint.NET com o comando:

wine paintdotnet.exe /wine

O parâmetro /wine é importante. Ele ativa o modo de compatibilidade experimental Wine/Linux do Paint.NET.

Se tudo estiver configurado corretamente, a interface gráfica do Paint.NET deve abrir.

Passo 12: Comando de inicialização conveniente

Depois que tudo estiver funcionando, você não precisa trocar de diretório antes.

Você pode iniciar o Paint.NET de qualquer lugar com:

WINEPREFIX="$HOME/.wine-paintnet" \
wine "$HOME/PaintDotNet/paintdotnet.exe" /wine

Este é o comando recomendado para uso no futuro.

Solução de problemas

Se o Paint.NET não iniciar, verifique o seguinte, nesta ordem.

Verifique o Wine

wine --version

Você deve ter Wine 11.14 ou mais novo para este experimento.

Verifique o prefixo Wine

echo "$WINEPREFIX"

Ele deve apontar para:

/home/YOUR_USERNAME/.wine-paintnet

Se estiver vazio ou incorreto:

export WINEPREFIX="$HOME/.wine-paintnet"

Verifique DXVK e as substituições de DLL

wine reg query "HKCU\Software\Wine\DllOverrides"

Confirme que d3dcompiler_47 está definido como native, junto com as substituições DXVK relevantes.

Verifique o Vulkan

vulkaninfo --summary

Se o Vulkan estiver indisponível, o DXVK não funciona corretamente.

Verifique o executável do Paint.NET

ls ~/PaintDotNet/paintdotnet.exe

Verifique o comando de inicialização

Use:

WINEPREFIX="$HOME/.wine-paintnet" \
wine "$HOME/PaintDotNet/paintdotnet.exe" /wine

Não omita /wine.

O que o modo /wine realmente faz

A opção /wine é mais do que um simples sinalizador de compatibilidade.

De acordo com o desenvolvedor do Paint.NET, esse modo desativa vários recursos específicos do Windows que não são apropriados nem funcionais no Wine, incluindo:

  • UIAnimation
  • Composition
  • Windows 11 DisplayInformation

Ele também ativa a implementação interna de Direct2D do Paint.NET contida em:

PaintDotNet.Windows.Direct2D1.Managed.dll

É essa tecnologia gráfica que torna o experimento possível sem exigir que o Wine forneça toda a funcionalidade Direct2D que o Paint.NET normalmente espera.

Expectativas de desempenho

O desempenho vai depender bastante da configuração gráfica do sistema Linux.

Um sistema com Vulkan acelerado por GPU deve oferecer uma experiência muito melhor do que um que depende de renderização por software.

Se o comando vulkaninfo --summary retornar:

llvmpipe

a renderização Vulkan está sendo feita pela CPU.

O Paint.NET ainda pode iniciar e funcionar, mas espere um desempenho mais lento, principalmente com:

  • Imagens grandes
  • Zoom
  • Operações de canvas
  • Efeitos que exigem muita GPU
  • Seleções ou transformações complexas

Isso não deve ser confundido com falha de compatibilidade do Paint.NET. O aplicativo pode rodar com sucesso mesmo quando a aceleração Vulkan é limitada.

Conclusão

Este experimento é interessante por um motivo que vai além do Paint.NET.

Durante muitos anos, alguns aplicativos Windows eram difíceis ou impossíveis de rodar corretamente no Linux porque dependiam de componentes do Windows que o Wine não implementava por completo.

Normalmente, resolver um problema assim significava que os desenvolvedores do Wine precisavam gastar muito tempo recriando a tecnologia Windows ausente.

O experimento do Paint.NET segue um caminho diferente.

Em vez de esperar que o Wine implemente tudo o que o Paint.NET precisa, o desenvolvedor usou um assistente de codificação por IA para criar uma implementação separada, específica para o Paint.NET.

Ainda é experimental, e há muitas perguntas em aberto sobre desempenho, confiabilidade, manutenibilidade e o uso de código gerado por IA.

Mas o experimento demonstra algo importante:

As ferramentas de codificação por IA estão se tornando capazes de ajudar desenvolvedores a construir componentes de software surpreendentemente grandes e tecnicamente complexos em um período muito curto.

Se essa abordagem vai produzir software confiável em escala ainda é uma questão em aberto.

Por enquanto, o Paint.NET no Linux deve ser visto não como uma versão Linux pronta, mas como um experimento fascinante em desenvolvimento de software assistido por IA, compatibilidade com Windows e o futuro da engenharia de software livre.

Referência rápida: instalação do Paint.NET no Ubuntu Linux

Para quem já tem o Ubuntu 26.04 instalado e quer apenas a sequência completa de comandos:

# Enable 32-bit packages
sudo dpkg --add-architecture i386
sudo apt update
# WineHQ prerequisites
sudo apt install wget gnupg2 software-properties-common
# WineHQ signing key
sudo mkdir -pm755 /etc/apt/keyrings
wget -qO- https://dl.winehq.org/wine-builds/winehq.key \
| gpg --dearmor \
| sudo tee /etc/apt/keyrings/winehq-archive.key > /dev/null
# WineHQ repository for Ubuntu 26.04
sudo wget -NP /etc/apt/sources.list.d/ \
https://dl.winehq.org/wine-builds/ubuntu/dists/resolute/winehq-resolute.sources
sudo apt update
# Install Wine Staging
sudo apt install --install-recommends winehq-staging
# Verify Wine
wine --version
# Create dedicated 64-bit Wine prefix
export WINEPREFIX="$HOME/.wine-paintnet"
export WINEARCH=win64
wineboot -u
# Install Wine configuration
winecfg
# Install Winetricks
sudo apt install winetricks
# Install required graphics components
export WINEPREFIX="$HOME/.wine-paintnet"
winetricks d3dcompiler_47 dxvk
# Verify DLL overrides
wine reg query "HKCU\Software\Wine\DllOverrides"
# Optional Vulkan diagnostic
sudo apt install vulkan-tools
vulkaninfo --summary
# Create Paint.NET directory
mkdir -p ~/PaintDotNet
# Extract the downloaded Paint.NET 5.2 Alpha portable ZIP
cd ~/PaintDotNet
unzip paint.net.5.200.9739.41506.portable.x64.zip
# Launch Paint.NET
WINEPREFIX="$HOME/.wine-paintnet" \
wine "$HOME/PaintDotNet/paintdotnet.exe" /wine

Recurso: