Arch User Repository (Português)

Translation Status: This article is a localized version of Arch User Repository. Last translation date: 2026-09-25. You can help to synchronize the translation, if there were changes in the English version.

O Arch User Repository (AUR) é um repositório mantido pela comunidade para usuários do Arch Linux. Ele contém descrições de pacotes (PKGBUILDs) que permitem compilar um pacote a partir do código-fonte com o makepkg e, em seguida, instalá-lo por meio do pacman. O AUR foi criado para organizar e compartilhar novos pacotes da comunidade e ajudar a acelerar a inclusão de pacotes populares no repositório extra. Este documento explica como os usuários podem acessar e utilizar o AUR.

Muitos dos novos pacotes que chegam aos repositórios oficiais começam no AUR. No AUR, os usuários podem contribuir com suas próprias receitas de compilação de pacotes (PKGBUILDs e arquivos relacionados). A comunidade do AUR tem a capacidade de votar em pacotes no AUR. Se um pacote se tornar popular o suficiente — desde que tenha uma licença compatível e uma boa técnica de empacotamento —, ele poderá ser inserido no repositório extra (acessível diretamente pelo pacman ou a partir do Sistema de compilação do Arch).

Warning Os pacotes do AUR são conteúdo fornecido pelos usuários. Os arquivos PKGBUILD são completamente não oficiais e não passam por uma auditoria minuciosa. O uso desses arquivos é de sua inteira responsabilidade.

Note Se você planeja usar o AUR, é altamente recomendado acompanhar a lista de discussão aur-general do Arch, que foi usada para avisos de segurança no passado. [1] [2] [3] [4] [5] [6] [7]

Começando

Os usuários podem pesquisar e baixar PKGBUILDs pela interface web do AUR. Esses arquivos podem ser compilados em pacotes instaláveis com o makepkg e, em seguida, instalados com o pacman.

Certifique-se de que o base-devel esteja instalado.
Consulte a seção #Perguntas frequentes para obter respostas às dúvidas mais comuns.
Você também pode ajustar o arquivo /etc/makepkg.conf para otimizar a compilação no seu sistema antes de compilar pacotes do AUR. Em sistemas com processadores multinúcleo, é possível reduzir significativamente o tempo de compilação ajustando a variável MAKEFLAGS, usando vários núcleos para a compressão ou escolhendo outro algoritmo de compressão. Também é possível habilitar otimizações do compilador específicas para o hardware por meio da variável CFLAGS. Consulte as opções de otimização do makepkg para obter mais informações.

Se você configurou a autenticação SSH do AUR, também é possível interagir com o AUR por SSH. Digite ssh aur@aur.archlinux.org help para obter uma lista dos comandos disponíveis.

Instalando e atualizando pacotes

A instalação de pacotes a partir do AUR é um processo relativamente simples. Essencialmente:

Obtenha os arquivos de compilação, incluindo o PKGBUILD e possivelmente outros arquivos necessários, como unidades do systemd e patches (muitas vezes, não o próprio código-fonte).
Verifique o PKGBUILD. Esta é a etapa mais importante para verificar se o PKGBUILD e os arquivos que o acompanham não são maliciosos nem pouco confiáveis.
Compile o pacote, executando makepkg no diretório onde os arquivos estão salvos. Isso baixará o código, o compilará e o empacotará.
Instale o pacote, executando pacman -U arquivo_do_pacote para instalar o pacote em seu sistema.

Primeiro, certifique-se de que as ferramentas necessárias estejam instaladas, instalando o base-devel; esse metapacote tem o make e outras ferramentas necessárias para compilar a partir do código-fonte, listadas como dependências.

Note Os pacotes no AUR pressupõem que o base-devel esteja instalado no ambiente de compilação.

Em seguida, escolha um diretório de compilação apropriado. Um diretório de compilação é simplesmente o local em que o pacote será criado ou compilado a partir do código-fonte; pode ser qualquer diretório. Os exemplos nas seções a seguir usarão ~/builds como o diretório de compilação.

Obter arquivos de compilação

Localize o pacote no AUR usando o campo de pesquisa na parte superior da página inicial do AUR. Clique no nome do pacote nos resultados para abrir sua página de informações. Leia a descrição para confirmar que encontrou o pacote desejado, confira a data da última atualização e leia os comentários.

Existem vários métodos para obter os arquivos de compilação de um pacote:

Clone o repositório Git do pacote, indicado como "Git Clone URL" na seção "Package Details" da página do AUR. Esse é o método preferido, pois permite obter facilmente as atualizações do pacote com git pull.

$ git clone https://aur.archlinux.org/nome_do_pacote.git

Baixe um snapshot clicando no link "Download snapshot", na seção "Package Actions", à direita da página do pacote no AUR. Também é possível baixá-lo pelo terminal:

$ curl -L -O https://aur.archlinux.org/cgit/aur.git/snapshot/nome_do_pacote.tar.gz

Note O arquivo snapshot está compactado e deve ser extraído (de preferência em um diretório reservado para compilações do AUR): tar -xvf nome_do_pacote.tar.gz

Use o espelho somente leitura archlinux/aur no GitHub, onde cada pacote está localizado em um branch. Recomenda-se clonar apenas um único branch (o repositório inteiro é muito grande e o desempenho seria baixo). Você pode fazer isso com um dos dois métodos a seguir:
- Usar git clone --single-branch:
```
$ git clone --branch nome_do_pacote --single-branch https://github.com/archlinux/aur.git
```
- Fazer uma clonagem parcial deste repositório (git clone --depth=1) e adicionar branches seletivamente:

$ git clone --depth=1 https://github.com/archlinux/aur.git; cd aur
$ git remote set-branches --add origin nome_do_pacote
$ git fetch
$ git switch nome_do_pacote

Verificar o PKGBUILD

Entre no diretório que contém o PKGBUILD do pacote.

$ cd nome_do_pacote

Warning Verifique cuidadosamente o PKGBUILD, quaisquer arquivos .install e quaisquer outros arquivos no repositório git do pacote em busca de comandos maliciosos ou perigosos. Em caso de dúvida, não compile o pacote e busque orientação nos fóruns ou na lista de discussão. Código malicioso já foi encontrado em pacotes anteriormente. [8] [9] [10] [11] Algumas ferramentas, como traur^AUR e ks-aur-scanner^AUR, estão disponíveis para auxiliar os usuários na verificação do conteúdo do PKGBUILD; no entanto, elas não substituem uma verificação manual cuidadosa.

Visualize o conteúdo de todos os arquivos fornecidos. Por exemplo, para usar o paginador less para visualizar o PKGBUILD, faça:

$ less PKGBUILD

Verifique se um arquivo de assinatura, com extensão .sig ou .asc, faz parte do array source do PKGBUILD. Nesse caso, obtenha uma das chaves públicas correspondentes às entradas do array validpgpkeys do PKGBUILD. Consulte verificação de assinaturas no makepkg para mais informações.

Esteja ciente de que códigos maliciosos também podem ser assinados. Por isso, examine cuidadosamente o PKGBUILD, especialmente as seções que possam baixar código de software de fora dos repositórios.

Tip Se estiver atualizando um pacote, pode ser útil examinar as alterações desde o último commit.

Para visualizar as alterações desde o último commit do Git, use git show.
Para visualizar as alterações desde o último commit com o vimdiff, execute git difftool @~..@ --tool=vimdiff. A vantagem do vimdiff é permitir visualizar o conteúdo completo de cada arquivo, com indicadores das alterações.

Compilar o pacote

This article or section needs expansion.

Reason: Sugere-se acrescentar informações sobre a compilação em um chroot limpo. (Discuss in Talk:Arch User Repository (Português))

Compile o pacote. Depois de verificar manualmente o conteúdo dos arquivos, execute o makepkg como usuário comum. Algumas opções úteis são:

-s/--syncdeps resolve e instala automaticamente quaisquer dependências com o pacman antes de compilar. Se o pacote depender de outros pacotes do AUR, você precisará instalá-los manualmente primeiro.
-i/--install instala o pacote se ele for compilado com sucesso. Isso permite ignorar a próxima etapa, que geralmente é feita manualmente.
-r/--rmdeps remove as dependências de compilação após o término, pois elas não são mais necessárias. No entanto, essas dependências podem precisar ser reinstaladas na próxima vez que o pacote for atualizado.
-c/--clean limpa arquivos temporários de compilação após a construção, pois não são mais necessários. Esses arquivos geralmente só são necessários ao depurar o processo de compilação.
--packagelist lista os nomes dos arquivos de pacote que seriam produzidos sem compilar.

Tip Use git clean -dfx para excluir todos os arquivos que não são rastreados pelo Git, removendo também os arquivos de pacotes compilados anteriormente.

Instalar o pacote

O pacote agora pode ser instalado com o pacman:

# pacman -U nome_do_pacote-versão-arquitetura.pkg.tar.zst

Note

Se você alterou seu PKGEXT no makepkg.conf, o nome do arquivo do pacote pode ser ligeiramente diferente.
O exemplo acima é apenas um breve resumo do processo de compilação. É altamente recomendado ler os artigos makepkg e Sistema de compilação do Arch para mais detalhes.

Atualizando pacotes

No diretório que contém o PKGBUILD do pacote, atualize os arquivos e obtenha as alterações mais recentes do repositório executando:

$ git pull

Em seguida, siga as instruções anteriores de compilação e instalação.

Mantendo pacotes atualizados

O AUR não oferece suporte oficial; portanto, a atualização dos pacotes que você instalar é de sua responsabilidade, não do pacman. Se os pacotes nos repositórios oficiais forem atualizados, você precisará recompilar todos os pacotes do AUR que dependam dessas bibliotecas. A ferramenta checkrebuild e o hook rebuild-detector do rebuild-detector podem ajudar a encontrar pacotes que precisam ser recompilados.

Status da conta

Suspensão

Ao editar a conta de um usuário, um mantenedor de pacote pode definir o campo Suspended, suspendendo essa conta. Quando um usuário está suspenso, ele não pode:

Fazer login em https://aur.archlinux.org
Receber notificações
Interagir com a interface Git

Inatividade

Ao editar a própria conta ou a conta de outra pessoa, um mantenedor de pacote pode definir o campo Inactive. As contas inativas são usadas por dois motivos:

Exibir, na página da conta, a data em que a pessoa foi marcada como inativa
Gerar uma contagem atualizada de mantenedores de pacotes ativos, com base na inatividade, para novas propostas

Feedback

Comentando em pacotes

A interface web do AUR possui um recurso de comentários que permite aos usuários enviar sugestões e comentários ao autor do PKGBUILD sobre possíveis melhorias.

Tip Evite colar patches ou arquivos PKGBUILD na seção de comentários: eles ficam desatualizados rapidamente e ocupam muito espaço desnecessariamente. Em vez disso, envie esses arquivos por e-mail ao mantenedor ou use um pastebin.

O Python-Markdown fornece sintaxe básica do Markdown para formatar comentários.

Note

Esta implementação possui algumas diferenças ocasionais em relação às regras de sintaxe oficiais.
Hashes de commit para o repositório Git do pacote e referências a chamados do Flyspray são convertidos em links automaticamente.
Comentários longos são recolhidos e podem ser expandidos sob demanda.

Votando em pacotes

Uma das atividades mais simples que todos os usuários do Arch podem realizar é navegar pelo AUR e votar em seus pacotes favoritos usando a interface on-line. Todos os pacotes podem ser adotados por um mantenedor de pacote para inclusão no repositório extra, e a quantidade de votos é um dos fatores considerados nesse processo. Portanto, é do interesse de todos votar!

Cadastre-se no site do AUR para que a opção "Vote for this package" apareça enquanto você navega pelos pacotes. Depois de se cadastrar, você também poderá votar pela linha de comando usando o aur-auto-vote-git^AUR.

Alternativamente, se você configurou a autenticação SSH do AUR, você pode votar diretamente da linha de comando usando sua chave SSH. Isso significa que você não precisará salvar ou digitar sua senha do AUR.

$ ssh aur@aur.archlinux.org vote nome_do_pacote

Marcando pacotes como desatualizados

Primeiro, marque o pacote como out-of-date (desatualizado) e informe o motivo. De preferência, inclua links para o anúncio de lançamento ou para o arquivo tarball da nova versão.

Você também deve tentar entrar em contato diretamente com o mantenedor por e-mail. Se não houver resposta do mantenedor após duas semanas, você pode registrar uma solicitação de orphan (orfandade). Veja Diretrizes de envio ao AUR#Solicitações para mais detalhes.

Note Os pacotes VCS não são considerados desatualizados quando o pkgver muda; não os marque como desatualizados, pois o mantenedor simplesmente removerá a marcação e ignorará o aviso. Os mantenedores do AUR não devem fazer commits apenas para atualizar o pkgver.

Depurando o processo de compilação do pacote

Certifique-se de que seu ambiente de compilação esteja atualizado realizando uma atualização dos pacotes antes de compilar qualquer coisa.
Certifique-se de ter o base-devel instalado.
Use a opção -s com o makepkg para verificar e instalar todas as dependências necessárias antes de iniciar o processo de compilação.
Tente a configuração padrão do makepkg.
Consulte solução de problemas do makepkg para problemas comuns.

Se tiver problemas para compilar um pacote, leia primeiro o PKGBUILD e os comentários na página do pacote no AUR.

É possível que um PKGBUILD esteja com problemas para todos os usuários. Se não conseguir resolver o problema por conta própria, informe o mantenedor, por exemplo, publicando os erros nos comentários da página do AUR. Você também pode pedir ajuda no fórum AUR Issues, Discussion & PKGBUILD Requests.

A causa do problema pode não ser tão simples. Valores personalizados para CFLAGS, LDFLAGS e MAKEFLAGS podem causar falhas. Para evitar problemas causados por sua configuração de sistema específica, compile os pacotes em um chroot limpo. Se o processo de compilação ainda falhar em um chroot limpo, o problema provavelmente está no PKGBUILD.

Consulte a seção sobre a verificação da integridade dos pacotes para saber mais sobre o namcap. Se quiser que um PKGBUILD seja revisado, publique-o na lista de discussão aur-general para receber comentários dos mantenedores de pacotes e de outros membros do AUR, ou no fórum Creating & Modifying Packages. Você também pode buscar ajuda no canal IRC #archlinux-aur na rede Libera Chat.

Enviando pacotes

Os usuários podem compartilhar PKGBUILDs usando o Arch User Repository. Veja Diretrizes de envio ao AUR para mais detalhes.

Tradução da interface web

Veja i18n.md na árvore de código-fonte do AUR para obter informações sobre como criar e manter traduções da interface web do AUR.

História

No início, existia o ftp://ftp.archlinux.org/incoming, e as pessoas contribuíam enviando ao servidor o PKGBUILD, os arquivos suplementares necessários e o próprio pacote compilado. O pacote e os arquivos associados permaneciam lá até que um "Trusted user" (termo posteriormente substituído por mantenedor de pacote) analisasse o programa e o adotasse.

Em seguida, nasceram os Trusted User Repositories. Certos indivíduos na comunidade tinham permissão para hospedar seus próprios repositórios para uso de qualquer pessoa. O AUR expandiu-se sobre essa base, com o objetivo de torná-lo mais flexível e mais utilizável. Na verdade, os mantenedores do AUR eram chamados de TUs (Trusted Users, ou usuários confiáveis) até a adoção do termo Package Maintainers (mantenedores de pacotes).

Entre 2015-06-08 e 2015-08-08, o AUR passou da versão 3.5.1 para a 4.0.0, introduzindo o uso de repositórios Git para publicar os PKGBUILDs. Os pacotes existentes foram descartados, a menos que seus mantenedores os migrassem manualmente para a nova infraestrutura.

Repositórios Git para pacotes do AUR3

O AUR Archive no GitHub possui um repositório para cada pacote que estava no AUR 3 no momento da migração. Alternativamente, existe o repositório aur3-mirror que oferece o mesmo conteúdo.

Perguntas frequentes

Que tipo de pacotes são permitidos no AUR?

Os pacotes no AUR são apenas "scripts de compilação", isto é, receitas para compilar binários para o pacman. Na maioria dos casos, tudo é permitido, sujeito às diretrizes de utilidade e escopo, desde que você esteja em conformidade com os termos de licença do conteúdo. Em outros casos, em que se menciona que não é permitido fazer link para downloads (isto é, conteúdo que não pode ser redistribuído), só é possível usar o próprio nome do arquivo como fonte. Isso significa, e exige, que os usuários já tenham o código-fonte restrito no diretório de compilação antes de compilar o pacote. Em caso de dúvida, pergunte.

Como posso votar em pacotes no AUR?

Veja #Votando em pacotes.

O que é um mantenedor de pacote?

Veja mantenedor de pacote.

Qual é a diferença entre o Arch User Repository e o repositório extra?

O Arch User Repository armazena os PKGBUILDs enviados pelos usuários, que devem ser compilados manualmente com o makepkg. Quando um PKGBUILD desperta interesse suficiente na comunidade e conta com o apoio de um mantenedor de pacote, o pacote pode ser movido para o repositório extra, mantido pelos mantenedores de pacotes. Nesse repositório, os pacotes binários podem ser instalados com o pacman.

Foo no AUR está desatualizado; o que devo fazer?

Veja #Marcando pacotes como desatualizados.

Enquanto isso, você pode tentar atualizar o pacote editando localmente o PKGBUILD. Às vezes, a atualização não exige mudanças no processo de compilação nem no pacote; nesses casos, basta atualizar o pkgver ou o array source.

Foo no AUR não compila quando eu executo o makepkg; o que devo fazer?

Provavelmente está faltando algo trivial; veja #Depurando o processo de compilação do pacote.

ERROR: One or more PGP signatures could not be verified!; o que devo fazer?

Provavelmente, você não tem no seu chaveiro pessoal as chaves públicas necessárias para verificar os arquivos baixados. Veja verificação de assinaturas no makepkg para detalhes.

Como crio um PKGBUILD?

Consulte as Diretrizes de envio ao AUR#Regras de envio e, em seguida, leia Criando pacotes.

Tenho um PKGBUILD que gostaria de enviar; alguém pode verificá-lo para ver se há erros?

Existem vários canais disponíveis para enviar seu pacote para revisão; veja #Depurando o processo de compilação do pacote.

Como colocar um PKGBUILD no repositório extra?

Normalmente, são necessários pelo menos 10 votos para que um pacote seja incluído no repositório extra. No entanto, se um mantenedor de pacote quiser apoiar um pacote, ele costuma ser encontrado no repositório.

Atingir o número mínimo de votos não é o único requisito: também é necessário haver um mantenedor disposto a manter o pacote. Os mantenedores de pacotes não são obrigados a mover um pacote para o repositório extra, mesmo que ele tenha milhares de votos.

Geralmente, quando um pacote muito popular permanece no AUR, é porque:

O Arch Linux já possui outra versão de um pacote nos repositórios
Sua licença proíbe a redistribuição
Ele ajuda os usuários a obter PKGBUILDs enviados pela comunidade. Os Auxiliares do AUR não contam com suporte oficial, por definição.

Veja também regras para entrada de pacotes no repositório extra.

Como posso acelerar processos de compilação repetidos?

Veja como melhorar os tempos de compilação do makepkg.

Qual é a diferença entre pacotes foo e foo-git?

Muitos pacotes do AUR têm versões de lançamento "estáveis" e versões de desenvolvimento "instáveis". Os pacotes de desenvolvimento geralmente têm um sufixo que indica o sistema de controle de versão utilizado. Eles não são destinados ao uso regular, mas podem oferecer novos recursos ou correções de erros. Como esses pacotes baixam o código-fonte mais recente disponível no momento em que você executa o makepkg, o pkgver() desses pacotes no AUR não reflete as alterações do projeto original (upstream). Da mesma forma, esses pacotes não conseguem verificar a autenticidade das fontes VCS por meio de uma soma de verificação.

Veja também uso de pacotes de software comprovados.

Por que foo desapareceu do AUR?

É possível que o pacote tenha sido adotado por um mantenedor de pacote e agora esteja no repositório extra.

Os pacotes podem ser excluídos se não cumprirem as regras de envio. Consulte o arquivo de mensagens de aur-requests para obter o motivo da exclusão.

Note O repositório Git de um pacote excluído normalmente permanece disponível. Consulte Diretrizes de envio ao AUR#Solicitações para mais detalhes.

Como descubro se algum dos meus pacotes instalados desapareceu do AUR?

Compare a saída do comando pacman -Qm (pacotes instalados que não são encontrados em bancos de dados sincronizados) com a lista de todos os pacotes do AUR:

$ comm -23 <(pacman -Qqm | sort) <(curl https://aur.archlinux.org/packages.gz | gzip -cd | sort)

Como posso obter uma lista de todos os pacotes do AUR?

Veja também