# SOME DESCRIPTIVE TITLE
# Copyright (C) 2021 the authors of Guix (msgids) and the following authors (msgstr)
# This file is distributed under the same license as the guix manual package.
# Rafael Fontenelle <rafaelff@gnome.org>, 2021.
# Thiago Jung Bauermann <bauermann@kolabnow.com>, 2021.
# Camila Flores Granella <cgranell@redhat.com>, 2022, 2023.
# Fábio Rodrigues Ribeiro <farribeiro@gmail.com>, 2022, 2023.
# Alexandre de Siqueira <alex.desiqueira@igdore.org>, 2023.
# Florian Pelz <pelzflorian@pelzflorian.de>, 2023, 2024, 2025.
# Frank McCay <frank.mccay@outlook.com.br>, 2024.
# Felipe Silva <fedora@felipeqq2.rocks>, 2024.
# Krascovict Petrov <krascovict@yandex.ru>, 2024.
# Weblate Translation Memory <noreply-mt-weblate-translation-memory@weblate.org>, 2024, 2025.
# Orahcio Felicio de Sousa <orahcio@gmail.com>, 2024.
# Arthur Rodrigues <arthurhdrodrigues@proton.me>, 2025.
msgid ""
msgstr ""
"Project-Id-Version: guix manual checkout\n"
"Report-Msgid-Bugs-To: bug-guix@gnu.org\n"
"POT-Creation-Date: 2026-03-15 03:18+0000\n"
"PO-Revision-Date: 2026-03-29 11:50+0000\n"
"Last-Translator: pelzflorian <pelzflorian@noreply.codeberg.org>\n"
"Language-Team: Portuguese (Brazil) <https://translate.codeberg.org/projects/guix/documentation-manual/pt_BR/>\n"
"Language: pt_BR\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=n > 1;\n"
"X-Generator: Weblate 5.16.2\n"

msgid "Contributing"
msgstr "Contribuindo"

msgid "This project is a cooperative effort, and we need your help to make it grow! Please get in touch with us on @email{guix-devel@@gnu.org} and @code{#guix} on the Libera Chat IRC network.  We welcome ideas, bug reports, patches, and anything that may be helpful to the project.  We particularly welcome help on packaging (@pxref{Packaging Guidelines})."
msgstr "Este projeto é um esforço cooperativo e precisamos da sua ajuda para fazê-lo crescer! Por favor, entre em contato conosco por meio de @email{guix-devel@@gnu.org} e @code{#guix} na rede IRC do Libera Chat. Ideias, relatórios de bugs, patches e qualquer coisa que possa ser útil para o projeto são sempre bem-vindos. Nós particularmente agradecemos a ajuda no empacotamento das (@pxref{Packaging Guidelines})."

msgid "code of conduct, of contributors"
msgstr "código de conduta, de contribuidores"

msgid "contributor covenant"
msgstr "acordo de contribuição"

msgid "We want to provide a warm, friendly, and harassment-free environment, so that anyone can contribute to the best of their abilities.  To this end our project uses a ``Contributor Covenant'', which was adapted from @url{https://contributor-covenant.org/}.  You can find a local version in the @file{CODE-OF-CONDUCT} file in the source tree."
msgstr "Queremos oferecer um ambiente acolhedor, amigável e sem assédio, para que todos possam contribuir com o melhor de suas habilidades. Para este fim, nosso projeto usa um ``Acordo de contribuição``, que foi adaptado de @url{https://contributor-covenant.org/}. Você pode encontrar uma versão local no arquivo @file{CODE-OF-CONDUCT} na árvore de fontes."

msgid "Contributors are not required to use their legal name in patches and on-line communication; they can use any name or pseudonym of their choice."
msgstr "Os contribuidores não são obrigados a usar seu nome legal em patches e comunicação on-line; eles podem usar qualquer nome ou pseudônimo de sua escolha."

msgid "Requirements"
msgstr "Requisitos"

msgid "Software needed to build and run Guix."
msgstr "Software necessário para compilar e executar o Guix."

msgid "Building from Git"
msgstr "Compilando do git"

msgid "The latest and greatest."
msgstr "A mais recente e melhor."

msgid "Running the Test Suite"
msgstr "Executando o conjunto de testes"

msgid "Testing Guix."
msgstr "Testando o Guix."

msgid "Running Guix Before It Is Installed"
msgstr "Executando guix antes dele ser instalado"

msgid "Hacker tricks."
msgstr "Truques de hacker."

msgid "The Perfect Setup"
msgstr "A configuração perfeita"

msgid "The right tools."
msgstr "As ferramentas certas."

msgid "Source Tree Structure"
msgstr "Estrutura da árvore de origem"

msgid "Source code guided tour."
msgstr "Visita guiada ao código-fonte."

msgid "Packaging Guidelines"
msgstr "Diretrizes de empacotamento"

msgid "Growing the distribution."
msgstr "Crescendo a distribuição."

msgid "Coding Style"
msgstr "Estilo de código"

msgid "Hygiene of the contributor."
msgstr "Limpeza do contribuidor."

msgid "Submitting Patches"
msgstr "Enviando patches"

msgid "Share your work."
msgstr "Compartilhe seu trabalho."

msgid "Tracking Bugs and Changes"
msgstr "Rastreando Bugs e Mudanças"

msgid "Keeping it all organized."
msgstr "Mantendo tudo organizado."

msgid "Teams"
msgstr "Equipes"

msgid "Coordinating efforts."
msgstr "Coordenando esforços."

msgid "Making Decisions"
msgstr "Tomando decisões"

msgid "Collectively choosing the way forward."
msgstr "Escolhendo coletivamente o caminho a seguir."

msgid "Commit Access"
msgstr "Confirmar acesso"

msgid "Pushing to the official repository."
msgstr "Submeter para o repositório oficial."

msgid "Reviewing the Work of Others"
msgstr "Revendo o trabalho de outros"

msgid "Some guidelines for sharing reviews."
msgstr "Algumas diretrizes para compartilhar avaliações."

msgid "Updating the Guix Package"
msgstr "Atualizando o pacote Guix"

msgid "Updating the Guix package definition."
msgstr "Atualizando a definição do pacote Guix."

msgid "Deprecation Policy"
msgstr "Política de depreciação"

msgid "Commitments and tools for deprecation."
msgstr "Compromissos e ferramentas para depreciação."

msgid "Writing Documentation"
msgstr "Escrevendo documentação"

msgid "Improving documentation in GNU Guix."
msgstr "Melhorando a documentação no GNU Guix."

msgid "Translating Guix"
msgstr "Traduzindo o Guix"

msgid "Make Guix speak your native language."
msgstr "Faça o Guix falar sua língua nativa."

msgid "Contributing to Guix's Infrastructure"
msgstr "Contribuindo para a infraestrutura Guix"

msgid "Make Guix ecosystem work better."
msgstr "Faça o ecossistema do guix funcionar melhor."

msgid "You can easily hack on Guix itself using Guix and Git, which we use for version control (@pxref{Building from Git})."
msgstr "Você pode facilmente hackear o próprio Guix usando Guix e Git, que usamos para controle de versão (@pxref{Building from Git})."

msgid "But when packaging Guix for foreign distros or when bootstrapping on systems without Guix, and if you decide to not just trust and install our readily made binary (@pxref{Binary Installation}), you can download a release version of our reproducible source tarball and read on."
msgstr "Mas ao empacotar o Guix para distribuições estrangeiras ou ao inicializar em sistemas sem Guix, e se você decidir não confiar e instalar nosso binário prontamente criado (@pxref{Binary Installation}), você pode baixar uma versão de lançamento do nosso tarball de código-fonte reproduzível e continuar lendo."

msgid "This section lists requirements when building Guix from source.  The build procedure for Guix is the same as for other GNU software, and is not covered here.  Please see the files @file{README} and @file{INSTALL} in the Guix source tree for additional details."
msgstr "Esta seção lista os requisitos ao compilar o Guix a partir do fonte. O procedimento de compilação do Guix é o mesmo que para outros softwares GNU, e não é coberto aqui. Por favor, veja os arquivos @file{README} e @file{INSTALL} na árvore fonte do Guix para detalhes adicionais."

msgid "official website"
msgstr "site oficial"

msgid "GNU Guix is available for download from its website at @url{https://guix.gnu.org}."
msgstr "O GNU Guix está disponível para download em seu site em @url{https://guix.gnu.org}."

msgid "GNU Guix depends on the following packages:"
msgstr "GNU Guix depende dos seguintes pacotes:"

msgid "@url{https://gnu.org/software/guile/, GNU Guile}, version 3.0.x,"
msgstr "@url{https://gnu.org/software/guile/, GNU Guile}, versão 3.0.x,"

msgid "version 3.0.9 or later;"
msgstr "versão 3.0.9 ou posterior;"

msgid "@url{https://codeberg.org/guile-gcrypt/guile-gcrypt, Guile-Gcrypt}, version"
msgstr "@url{https://codeberg.org/guile-gcrypt/guile-gcrypt, Guile-Gcrypt}, versão"

msgid "0.1.0 or later;"
msgstr "0.1.0 ou posterior;"

msgid "@uref{https://gitlab.com/gnutls/guile/, Guile-GnuTLS} (@pxref{Guile Preparations, how to install the GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile})@footnote{The Guile bindings to @uref{https://gnutls.org/, GnuTLS} were distributed as part of GnuTLS until version 3.7.8 included.};"
msgstr "@uref{https://gitlab.com/gnutls/guile/, Guile-GnuTLS} (@pxref{Guile Preparations, como instalar as ligações do GnuTLS para o Guile, gnutls-guile, GnuTLS-Guile})@footnote{As ligações do Guile para @uref{https://gnutls.org/, GnuTLS} foram distribuídas como parte do GnuTLS até a versão 3.7.8 incluída.};"

msgid "@uref{https://codeberg.org/guile-sqlite3/guile-sqlite3, Guile-SQLite3}, version 0.1.0 or later;"
msgstr "@uref{https://codeberg.org/guile-sqlite3/guile-sqlite3, Guile-SQLite3}, versão 0.1.0 ou posterior;"

msgid "version 0.1.0 or later;"
msgstr "versão 0.1.0 ou posterior;"

msgid "@uref{https://codeberg.org/guile-compression/guile-lzlib, Guile-lzlib};"
msgstr "@uref{https://codeberg.org/guile-compression/guile-lzlib, Guile-lzlib};"

msgid "@uref{https://www.nongnu.org/guile-avahi/, Guile-Avahi};"
msgstr "@uref{https://www.nongnu.org/guile-avahi/, Guile-Avahi};"

msgid "@uref{https://gitlab.com/guile-git/guile-git, Guile-Git}, version 0.10.0 or later;"
msgstr "@uref{https://gitlab.com/guile-git/guile-git, Guile-Git}, versão 0.10.0 ou posterior;"

msgid "@uref{https://git-scm.com, Git} (yes, both!);"
msgstr "@uref{https://git-scm.com, Git} (sim, ambos!);"

msgid "@uref{https://github.com/aconchillo/guile-json, Guile-JSON}"
msgstr "@uref{https://github.com/aconchillo/guile-json, Guile-JSON}"

msgid "4.3.0 or later;"
msgstr "4.3.0 ou posterior;"

msgid "@url{https://www.gnu.org/software/make/, GNU Make}."
msgstr "@url{https://www.gnu.org/software/make/, GNU Make}."

msgid "The following dependencies are optional:"
msgstr "As seguintes dependências são opcionais:"

msgid "Support for build offloading (@pxref{Daemon Offload Setup}) and @command{guix copy} (@pxref{Invoking guix copy}) depends on @uref{https://github.com/artyom-poptsov/guile-ssh, Guile-SSH}, version 0.13.0 or later."
msgstr "O suporte para descarregamento de compilação (@pxref{Daemon Offload Setup}) e @command{guix copy} (@pxref{Invoking guix copy}) depende do @uref{https://github.com/artyom-poptsov/guile-ssh, Guile-SSH}, versão 0.13.0 ou posterior."

msgid "@uref{https://codeberg.org/guile-compression/guile-zstd, Guile-zstd}, for zstd compression and decompression in @command{guix publish} and for substitutes (@pxref{Invoking guix publish})."
msgstr "@uref{https://codeberg.org/guile-compression/guile-zstd, Guile-zstd}, para compressão e descompressão zstd em @command{guix publish} e para substitutos (@pxref{Invoking guix publish})."

msgid "@uref{https://ngyro.com/software/guile-semver.html, Guile-Semver} for the @code{crate} importer (@pxref{Invoking guix import})."
msgstr "@uref{https://ngyro.com/software/guile-semver.html, Guile-Semver} para o importador @code{crate} (@pxref{Invoking guix import})."

msgid "@uref{https://www.nongnu.org/guile-lib/doc/ref/htmlprag/, Guile-Lib} for the @code{go} importer (@pxref{Invoking guix import}) and for some of the ``updaters'' (@pxref{Invoking guix refresh})."
msgstr "@uref{https://www.nongnu.org/guile-lib/doc/ref/htmlprag/, Guile-Lib} para o importador @code{go} (@pxref{Invoking guix import}) e para alguns dos ``atualizadores'' (@pxref{Invoking guix refresh})."

msgid "When @url{http://www.bzip.org, libbz2} is available, @command{guix-daemon} can use it to compress build logs."
msgstr "Quando @url{http://www.bzip.org, libbz2} está disponível, @command{guix-daemon} pode usá-lo para comprimir logs de compilação."

msgid "Unless @option{--disable-daemon} was passed to @command{configure}, the following packages are also needed:"
msgstr "A menos que @option{--disable-daemon} tenha sido passado para @command{configure}, os seguintes pacotes também são necessários:"

msgid "@url{https://gnupg.org/, GNU libgcrypt};"
msgstr "@url{https://gnupg.org/, GNU libgcrypt};"

msgid "@url{https://sqlite.org, SQLite 3};"
msgstr "@url{https://sqlite.org, SQLite 3};"

msgid "@url{https://gcc.gnu.org, GCC's g++}, with support for the"
msgstr "@url{https://gcc.gnu.org, GCC's g++}, com suporte ao"

msgid "C++11 standard."
msgstr "padrão C++11."

msgid "If you want to hack Guix itself, it is recommended to use the latest version from the Git repository@footnote{ Guix uses @code{master} as the default branch name. A proposal in 2025 to change the default branch name to @code{main} did not reach consensus.  See @uref{https://codeberg.org/guix/guix-consensus-documents/src/branch/main/003-rename-default-branch.md, Guix Consensus Document 003}.}:"
msgstr "Se você quiser hackear o próprio Guix, é recomendado usar a versão mais recente do repositório Git@footnote{ Guix usa @code{master} como a sua branch principal. Uma proposta de 2025 para mudar esse nome para @code{main} não obteve consenso.  Veja @uref{https://codeberg.org/guix/guix-consensus-documents/src/branch/main/003-rename-default-branch.md, Documento de Consenso do Guix 003}.}:"

msgid ""
"git clone https://git.guix.gnu.org/guix.git\n"
"cd guix\n"
msgstr ""
"git clone https://git.guix.gnu.org/guix.git\n"
"cd guix\n"

msgid "authentication, of a Guix checkout"
msgstr "autenticação, de um checkout Guix"

msgid "How do you ensure that you obtained a genuine copy of the repository? To do that, run @command{guix git authenticate}, passing it the commit and OpenPGP fingerprint of the @dfn{channel introduction} (@pxref{Invoking guix git authenticate}):"
msgstr "Como você garante que obteve uma cópia genuína do repositório? Para fazer isso, execute @command{guix git authenticate}, passando a ele o commit e a impressão digital OpenPGP do @dfn{introdução ao canal} (@pxref{Invoking guix git authenticate}):"

msgid ""
"git fetch origin keyring:keyring\n"
"guix git authenticate 9edb3f66fd807b096b48283debdcddccfea34bad \\\n"
"  \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\"\n"
msgstr ""
"git fetch origin keyring:keyring\n"
"guix git authenticate 9edb3f66fd807b096b48283debdcddccfea34bad \\\n"
"  \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\"\n"

msgid "This command completes with exit code zero on success; it prints an error message and exits with a non-zero code otherwise."
msgstr "Este comando é concluído com um código de saída zero em caso de sucesso; caso contrário, ele imprime uma mensagem de erro e sai com um código diferente de zero."

msgid "As you can see, there is a chicken-and-egg problem: you first need to have Guix installed.  Typically you would install Guix System (@pxref{System Installation}) or Guix on top of another distro (@pxref{Binary Installation}); in either case, you would verify the OpenPGP signature on the installation medium.  This ``bootstraps'' the trust chain."
msgstr "Como você pode ver, há um problema de ovo e galinha: primeiro você precisa ter o Guix instalado. Normalmente você instalaria o Guix System (@pxref{System Installation}) ou o Guix em cima de outra distro (@pxref{Binary Installation}); em ambos os casos, você verificaria a assinatura OpenPGP na mídia de instalação. Isso ``bootstraps'' a cadeia de confiança."

msgid "The easiest way to set up a development environment for Guix is, of course, by using Guix! The following command starts a new shell where all the dependencies and appropriate environment variables are set up to hack on Guix:"
msgstr "A maneira mais fácil de configurar um ambiente de desenvolvimento para Guix é, claro, usando Guix! O comando a seguir inicia um novo shell onde todas as dependências e variáveis de ambiente apropriadas são configuradas para hackear em Guix:"

msgid "guix shell -D guix -CPW\n"
msgstr "guix shell -D guix -CPW\n"

msgid "or even, from within a Git worktree for Guix:"
msgstr "ou mesmo, de dentro de uma árvore de trabalho Git para Guix:"

msgid ""
"echo $(pwd) >> ~/.config/guix/shell-authorized-directories\n"
"guix shell -CPW\n"
msgstr ""
"echo $(pwd) >> ~/.config/guix/shell-authorized-directories\n"
"guix shell -CPW\n"

msgid "If @option{-C} (short for @option{--container}) is not supported on your system, try @command{--pure} instead of @option{-CPW}.  @xref{Invoking guix shell}, for more information on that command."
msgstr "Se @option{-C} (abreviação de @option{--container}) não for compatível com seu sistema, tente @command{--pure} em vez de @option{-CPW}. @xref{Invoking guix shell}, para obter mais informações sobre esse comando."

msgid "Most of the test suite runs without an internet connection. The @option{-N} (short for @option{--network}) can be added to the @code{guix shell} command to run the tests that require internet access."
msgstr "A maior parte do conjunto de testes é executada sem conexão com a internet. A opção @option{-N} (abreviação de @option{--network}) pode ser adicionada ao comando `guix shell` para executar os testes que exigem acesso à internet."

msgid "If you are unable to use Guix when building Guix from a checkout, the following are the required packages in addition to those mentioned in the installation instructions (@pxref{Requirements})."
msgstr "Se você não conseguir usar o Guix ao criar o Guix a partir de um checkout, a seguir estão os pacotes necessários, além daqueles mencionados nas instruções de instalação (@pxref{Requirements})."

msgid "@url{https://gnu.org/software/autoconf/, GNU Autoconf};"
msgstr "@url{https://gnu.org/software/autoconf/, GNU Autoconf};"

msgid "@url{https://gnu.org/software/automake/, GNU Automake};"
msgstr "@url{https://gnu.org/software/automake/, GNU Automake};"

msgid "@url{https://gnu.org/software/gettext/, GNU Gettext};"
msgstr "@url{https://gnu.org/software/gettext/, GNU Gettext};"

msgid "@url{https://gnu.org/software/texinfo/, GNU Texinfo};"
msgstr "@url{https://gnu.org/software/texinfo/, GNU Texinfo};"

msgid "@url{https://www.graphviz.org/, Graphviz};"
msgstr "@url{https://www.graphviz.org/, Graphviz};"

msgid "@url{https://www.gnu.org/software/help2man/, GNU Help2man (optional)}."
msgstr "@url{https://www.gnu.org/software/help2man/, GNU Help2man (opcional)}."

msgid "On Guix, other development tools, like @code{strace}, can be included by giving them as extra arguments to @command{guix shell}:"
msgstr "No Guix, outras ferramentas de desenvolvimento, como @code{strace}, podem ser incluídas ao adicioná-las como argumento ao @command{guix shell}:"

msgid "guix shell -D guix -CPW strace\n"
msgstr "guix shell -D guix -CPW strace\n"

msgid "From there you can generate the build system infrastructure using Autoconf and Automake:"
msgstr "A partir daí você pode gerar a infraestrutura do sistema de construção usando Autoconf e Automake:"

msgid "./bootstrap\n"
msgstr "./bootstrap\n"

msgid "If you get an error like this one:"
msgstr "Se você receber um erro como este:"

msgid "configure.ac:46: error: possibly undefined macro: PKG_CHECK_MODULES\n"
msgstr "configure.ac:46: error: possibly undefined macro: PKG_CHECK_MODULES\n"

msgid "it probably means that Autoconf couldn’t find @file{pkg.m4}, which is provided by pkg-config.  Make sure that @file{pkg.m4} is available.  The same holds for the @file{guile.m4} set of macros provided by Guile.  For instance, if you installed Automake in @file{/usr/local}, it wouldn’t look for @file{.m4} files in @file{/usr/share}.  In that case, you have to invoke the following command:"
msgstr "provavelmente significa que o Autoconf não conseguiu encontrar o @file{pkg.m4}, que é fornecido pelo pkg-config. Certifique-se de que @file{pkg.m4} esteja disponível. O mesmo vale para o conjunto de macros @file{guile.m4} fornecido pelo Guile. Por exemplo, se você instalou o Automake em @file{/usr/local}, ele não procuraria arquivos @file{.m4} em @file{/usr/share}. Nesse caso, você tem que invocar o seguinte comando:"

msgid "export ACLOCAL_PATH=/usr/share/aclocal\n"
msgstr "export ACLOCAL_PATH=/usr/share/aclocal\n"

msgid "@xref{Macro Search Path,,, automake, The GNU Automake Manual}, for more information."
msgstr "@xref{Macro Search Path,,, automake, The GNU Automake Manual}, para mais informações."

msgid "state directory"
msgstr "diretório de estado"

msgid "localstatedir"
msgstr "localstatedir"

msgid "system configuration directory"
msgstr "diretório de configuração do sistema"

msgid "sysconfdir"
msgstr "sysconfdir"

msgid "Then, run:"
msgstr "Então, execute:"

msgid "./configure\n"
msgstr "./configure\n"

msgid "Optionally, @code{--localstatedir} and @code{--sysconfdir} can also be provided as arguments.  By default, @code{localstatedir} is @file{/var} (@pxref{The Store}, for information about this) and @code{sysconfdir} is @file{/etc}.  Note that you will probably not run @command{make install} at the end (you don't have to) but it's still important to pass the right @code{localstatedir} and @code{sysconfdir} values, which get recorded in the @code{(guix config)} Guile module."
msgstr "Opcionalmente, @code{--localstatedir} e @code{--sysconfdir} podem também ser providenciados como argumentos.  Por padrão, @code{localstatedir} é @file{/var} (@pxref{The Store}, para obter informações sobre isso) e @file{/etc} é o valor normal de @code{sysconfdir}. Observe que você provavelmente não executará @command{make install} no final (não é necessário), mas ainda é importante passar os valores @code{localstatedir} e @code{sysconfdir} corretos, que são registrados no módulo @code{(guix config)} do Guile."

msgid "Finally, you can build Guix and, if you feel so inclined, run the tests (@pxref{Running the Test Suite}):"
msgstr "Finalmente, você pode construir o Guix e, se desejar, executar os testes (@pxref{Running the Test Suite}):"

msgid ""
"make\n"
"make check\n"
msgstr ""
"make\n"
"make check\n"

msgid "If anything fails, take a look at installation instructions (@pxref{Installation}) or send a message to the @email{guix-devel@@gnu.org, mailing list}."
msgstr "Se alguma coisa falhar, dê uma olhada nas instruções de instalação (@pxref{Installation}) ou envie uma mensagem para a @email{guix-devel@@gnu.org, a lista de discussão}."

msgid "From there on, you can authenticate all the commits included in your checkout by running:"
msgstr "A partir daí, você pode autenticar todos os commits incluídos no seu checkout executando:"

msgid ""
"guix git authenticate \\\n"
"  9edb3f66fd807b096b48283debdcddccfea34bad \\\n"
"  \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\"\n"
msgstr ""
"guix git authenticate \\\n"
"  9edb3f66fd807b096b48283debdcddccfea34bad \\\n"
"  \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\"\n"

msgid "The first run takes a couple of minutes, but subsequent runs are faster.  On subsequent runs, you can run the command without any arguments since the @dfn{introduction} (the commit ID and OpenPGP fingerprints above)  will have been recorded@footnote{This requires a recent version of Guix, from May 2024 or more recent.}:"
msgstr "A primeira execução leva alguns minutos, mas as execuções subsequentes são mais rápidas. Em execuções subsequentes, você pode executar o comando sem argumentos, já que o @dfn{introduction} (o ID de confirmação e as impressões digitais do OpenPGP acima) terão sido registrados@footnote{Isso requer uma versão recente do Guix, de maio de 2024 ou mais recente.}:"

msgid "guix git authenticate\n"
msgstr "guix git authenticate\n"

msgid "When your configuration for your local Git repository doesn't match the default one, you can provide the reference for the @code{keyring} branch @i{via} the @option{-k} option.  The following example assumes that you have a Git remote called @samp{myremote} pointing to the official repository:"
msgstr "Quando sua configuração para seu repositório Git local não corresponde ao padrão, você pode fornecer a referência para o branch @code{keyring} @i{via} a opção @option{-k}. O exemplo a seguir pressupõe que você tenha um Git remoto chamado @samp{myremote} apontando para o repositório oficial:"

msgid ""
"guix git authenticate \\\n"
"  -k myremote/keyring \\\n"
"  9edb3f66fd807b096b48283debdcddccfea34bad \\\n"
"  \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\"\n"
msgstr ""
"guix git authenticate \\\n"
"  -k myremote/keyring \\\n"
"  9edb3f66fd807b096b48283debdcddccfea34bad \\\n"
"  \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\"\n"

msgid "@xref{Invoking guix git authenticate}, for more information on this command."
msgstr "@xref{Invoking guix git authenticate}, para mais informações sobre este comando."

msgid "Note"
msgstr "Nota"

msgid "By default, hooks are installed such that @command{guix git authenticate} is invoked anytime you run @command{git pull} or @command{git push}."
msgstr "Por padrão, os hooks são instalados de forma que @command{guix git authenticate} seja invocado sempre que você executar @command{git pull} ou @command{git push}."

msgid "After updating the repository, @command{make} might fail with an error similar to the following example:"
msgstr "Após atualizar o repositório, @command{make} pode falhar com um erro semelhante ao exemplo a seguir:"

msgid ""
"error: failed to load 'gnu/packages/linux.scm':\n"
"ice-9/eval.scm:293:34: In procedure abi-check: #<record-type <origin>>: record ABI mismatch; recompilation needed\n"
msgstr ""
"error: failed to load 'gnu/packages/linux.scm':\n"
"ice-9/eval.scm:293:34: In procedure abi-check: #<record-type <origin>>: record ABI mismatch; recompilation needed\n"

msgid "This means that one of the record types that Guix defines (in this example, the @code{origin} record) has changed, and all of guix needs to be recompiled to take that change into account.  To do so, run @command{make clean-go} followed by @command{make}."
msgstr "Isso significa que um dos tipos de registro que o Guix define (neste exemplo, o registro @code{origin}) foi alterado e todo o guix precisa ser recompilado para levar essa mudança em consideração. Para fazer isso, execute @command{make clean-go} seguido de @command{make}."

msgid "Should @command{make} fail with an Automake error message after updating, you need to repeat the steps outlined in this section, commencing with @command{./bootstrap}."
msgstr "Caso @command{make} falhe com uma mensagem de erro do Automake após a atualização, você precisará repetir as etapas descritas nesta seção, começando com @command{./bootstrap}."

msgid "test suite"
msgstr "suíte/conjunto de testes"

msgid "After a successful @command{configure} and @code{make} run, it is a good idea to run the test suite.  It can help catch issues with the setup or environment, or bugs in Guix itself---and really, reporting test failures is a good way to help improve the software.  To run the test suite, type:"
msgstr "Depois que um @command{configure} e @code{make} bem-sucedido forem executados, é uma boa ideia executar o conjunto de testes. Ele pode ajudar a detectar problemas com a configuração ou o ambiente, ou com bugs no próprio Guix – e realmente, relatar falhas de teste é uma boa maneira de ajudar a melhorar o software. Para executar o conjunto de testes, digite:"

msgid "make check\n"
msgstr "make check\n"

msgid "Test cases can run in parallel: you can use the @code{-j} option of GNU@tie{}make to speed things up.  The first run may take a few minutes on a recent machine; subsequent runs will be faster because the store that is created for test purposes will already have various things in cache."
msgstr "Os casos de teste podem ser executados em paralelo: você pode usar a opção @code{-j} do GNU@tie{}make para acelerar as coisas. A primeira execução pode levar alguns minutos em uma máquina recente; as execuções subsequentes serão mais rápidas porque o armazém criado para fins de teste já terá vários itens no cache."

msgid "It is also possible to run a subset of the tests by defining the @code{TESTS} makefile variable as in this example:"
msgstr "Também é possível executar um subconjunto dos testes definindo a variável makefile @code{TESTS} como neste exemplo:"

msgid "make check TESTS=\"tests/store.scm tests/cpio.scm\"\n"
msgstr "make check TESTS=\"tests/store.scm tests/cpio.scm\"\n"

msgid "By default, tests results are displayed at a file level.  In order to see the details of every individual test cases, it is possible to define the @code{SCM_LOG_DRIVER_FLAGS} makefile variable as in this example:"
msgstr "Por padrão, os resultados dos testes são exibidos em um nível de arquivo. Para ver os detalhes de cada caso de teste individual, é possível definir a variável makefile @code{SCM_LOG_DRIVER_FLAGS} como neste exemplo:"

msgid "make check TESTS=\"tests/base64.scm\" SCM_LOG_DRIVER_FLAGS=\"--brief=no\"\n"
msgstr "make check TESTS=\"tests/base64.scm\" SCM_LOG_DRIVER_FLAGS=\"--brief=no\"\n"

msgid "The underlying SRFI 64 custom Automake test driver used for the 'check' test suite (located at @file{build-aux/test-driver.scm}) also allows selecting which test cases to run at a finer level, via its @option{--select} and @option{--exclude} options.  Here's an example, to run all the test cases from the @file{tests/packages.scm} test file whose names start with ``transaction-upgrade-entry'':"
msgstr "O driver de teste Automake personalizado SRFI 64 subjacente usado para o conjunto de testes 'check' (localizado em @file{build-aux/test-driver.scm}) também permite selecionar quais casos de teste executar em um nível mais fino, por meio de suas opções @option{--select} e @option{--exclude}. Aqui está um exemplo, para executar todos os casos de teste do arquivo de teste @file{tests/packages.scm} cujos nomes começam com ``transaction-upgrade-entry'':"

msgid ""
"export SCM_LOG_DRIVER_FLAGS=\"--select=^transaction-upgrade-entry\"\n"
"make check TESTS=\"tests/packages.scm\"\n"
msgstr ""
"export SCM_LOG_DRIVER_FLAGS=\"--select=^transaction-upgrade-entry\"\n"
"make check TESTS=\"tests/packages.scm\"\n"

msgid "Those wishing to inspect the results of failed tests directly from the command line can add the @option{--errors-only=yes} option to the @code{SCM_LOG_DRIVER_FLAGS} makefile variable and set the @code{VERBOSE} Automake makefile variable, as in:"
msgstr "Aqueles que desejam inspecionar os resultados de testes com falha diretamente da linha de comando podem adicionar a opção @option{--errors-only=yes} à variável makefile @code{SCM_LOG_DRIVER_FLAGS} e definir a variável makefile do Automake @code{VERBOSE}, como em:"

msgid "make check SCM_LOG_DRIVER_FLAGS=\"--brief=no --errors-only=yes\" VERBOSE=1\n"
msgstr "make check SCM_LOG_DRIVER_FLAGS=\"--brief=no --errors-only=yes\" VERBOSE=1\n"

msgid "The @option{--show-duration=yes} option can be used to print the duration of the individual test cases, when used in combination with @option{--brief=no}:"
msgstr "A opção @option{--show-duration=yes} pode ser usada para imprimir a duração dos casos de teste individuais, quando usada em combinação com @option{--brief=no}:"

msgid "make check SCM_LOG_DRIVER_FLAGS=\"--brief=no --show-duration=yes\"\n"
msgstr "make check SCM_LOG_DRIVER_FLAGS=\"--brief=no --show-duration=yes\"\n"

msgid "@xref{Parallel Test Harness,,,automake,GNU Automake} for more information about the Automake Parallel Test Harness."
msgstr "@xref{Parallel Test Harness,,,automake,GNU Automake} para mais informações sobre o Automake Parallel Test Harness."

msgid "Upon failure, please email @email{bug-guix@@gnu.org} and attach the @file{test-suite.log} file.  Please specify the Guix version being used as well as version numbers of the dependencies (@pxref{Requirements}) in your message."
msgstr "Em caso de falha, envie um e-mail para @email{bug-guix@@gnu.org} e anexe o arquivo @file{test-suite.log}. Por favor, especifique a versão do Guix que está sendo usada, bem como os números de versão das dependências (@pxref{Requirements}) em sua mensagem."

msgid "Guix also comes with a whole-system test suite that tests complete Guix System instances.  It can only run on systems where Guix is already installed, using:"
msgstr "O Guix também vem com um conjunto de testes de sistema completo que testa instâncias completas do Guix System. Ele só pode ser executado em sistemas nos quais o Guix já está instalado, usando:"

msgid "make check-system\n"
msgstr "make check-system\n"

msgid "or, again, by defining @code{TESTS} to select a subset of tests to run:"
msgstr "ou, novamente, definindo @code{TESTS} para selecionar um subconjunto de testes a serem executados:"

msgid "make check-system TESTS=\"basic mcron\"\n"
msgstr "make check-system TESTS=\"basic mcron\"\n"

msgid "These system tests are defined in the @code{(gnu tests @dots{})} modules.  They work by running the operating systems under test with lightweight instrumentation in a virtual machine (VM).  They can be computationally intensive or rather cheap, depending on whether substitutes are available for their dependencies (@pxref{Substitutes}).  Some of them require a lot of storage space to hold VM images."
msgstr "Esses testes de sistema são definidos nos módulos @code{(gnu tests @dots{})}. Eles trabalham executando os sistemas operacionais em teste com instrumentação leve em uma máquina virtual (VM). Eles podem ser computacionalmente intensivos ou bastante baratos, dependendo se os substitutos estão disponíveis para suas dependências (@pxref{Substitutes}). Alguns deles exigem muito espaço de armazenamento para armazenar imagens de VM."

msgid "If you encounter an error like:"
msgstr "Se você encontrar um erro como:"

msgid ""
"Compiling Scheme modules...\n"
"ice-9/eval.scm:142:16: In procedure compile-top-call:\n"
"error: all-system-tests: unbound variable\n"
"hint: Did you forget `(use-modules (gnu tests))'?\n"
msgstr ""
"Compiling Scheme modules...\n"
"ice-9/eval.scm:142:16: In procedure compile-top-call:\n"
"error: all-system-tests: unbound variable\n"
"dica: Você se esqueceu de `(use-modules (gnu tests))'?\n"

msgid "there may be inconsistencies in the work tree from previous builds.  To resolve this, try running @command{make clean-go} followed by @command{make}."
msgstr "pode haver inconsistências na árvore de trabalho de compilações anteriores. Para resolver isso, tente executar @command{make clean-go} seguido por @command{make}."

msgid "Again in case of test failures, please send @email{bug-guix@@gnu.org} all the details."
msgstr "Novamente, em caso de falhas nos testes, por favor envie @email{bug-guix@@gnu.org} todos os detalhes."

msgid "In order to keep a sane working environment, you will find it useful to test the changes made in your local source tree checkout without actually installing them.  So that you can distinguish between your ``end-user'' hat and your ``motley'' costume."
msgstr "Para manter um ambiente de trabalho saudável, você achará útil testar as alterações feitas na árvore local de fontes sem realmente instalá-las. Para que você possa distinguir entre o seu chapéude ''usuário final'' e sua fantasia ''misturada''."

msgid "To that end, all the command-line tools can be used even if you have not run @code{make install}.  To do that, you first need to have an environment with all the dependencies available (@pxref{Building from Git}), and then simply prefix each command with @command{./pre-inst-env} (the @file{pre-inst-env} script lives in the top build tree of Guix; @pxref{Building from Git} to generate it).  As an example, here is how you would build the @code{hello} package as defined in your working tree (this assumes @command{guix-daemon} is already running on your system; it's OK if it's a different version):"
msgstr "Para esse fim, todas as ferramentas de linha de comando podem ser usadas mesmo se você não tiver executado @code{make install}. Para fazer isso, primeiro você precisa ter um ambiente com todas as dependências disponíveis (@pxref{Building from Git}) e, em seguida, simplesmente prefixar cada comando com @command{./pre-inst-env} (o @file{pre-inst-env} fica na árvore de construção superior do Guix; @pxref{Building from Git} para gerá-lo). Como exemplo, aqui está como você construiria o pacote @code{hello} conforme definido em sua árvore de trabalho (isso pressupõe que @command{guix-daemon} já esteja em execução em seu sistema; não há problema se for uma versão diferente):"

msgid "$ ./pre-inst-env guix build hello\n"
msgstr "$ ./pre-inst-env guix build hello\n"

msgid "Similarly, an example for a Guile session using the Guix modules:"
msgstr "Da mesma forma, um exemplo para uma sessão do Guile usando os módulos Guix:"

msgid ""
"$ ./pre-inst-env guile -c '(use-modules (guix utils)) (pk (%current-system))'\n"
"\n"
msgstr ""
"$ ./pre-inst-env guile -c '(use-modules (guix utils)) (pk (%current-system))'\n"
"\n"

msgid ";;; (\"x86_64-linux\")\n"
msgstr ";;; (\"x86_64-linux\")\n"

msgid "REPL"
msgstr "REPL"

msgid "read-eval-print loop"
msgstr "read-eval-print loop"

msgid "@dots{} and for a REPL (@pxref{Using Guix Interactively}):"
msgstr "@dots{} e para um REPL (@pxref{Using Guix Interactively}):"

msgid ""
"$ ./pre-inst-env guile\n"
"scheme@@(guile-user)> ,use(guix)\n"
"scheme@@(guile-user)> ,use(gnu)\n"
"scheme@@(guile-user)> (define snakes\n"
"                       (fold-packages\n"
"                         (lambda (package lst)\n"
"                           (if (string-prefix? \"python\"\n"
"                                               (package-name package))\n"
"                               (cons package lst)\n"
"                               lst))\n"
"                         '()))\n"
"scheme@@(guile-user)> (length snakes)\n"
"$1 = 361\n"
msgstr ""
"$ ./pre-inst-env guile\n"
"scheme@@(guile-user)> ,use(guix)\n"
"scheme@@(guile-user)> ,use(gnu)\n"
"scheme@@(guile-user)> (define snakes\n"
"                       (fold-packages\n"
"                         (lambda (package lst)\n"
"                           (if (string-prefix? \"python\"\n"
"                                               (package-name package))\n"
"                               (cons package lst)\n"
"                               lst))\n"
"                         '()))\n"
"scheme@@(guile-user)> (length snakes)\n"
"$1 = 361\n"

msgid "If you are hacking on the daemon and its supporting code or if @command{guix-daemon} is not already running on your system, you can launch it straight from the build tree@footnote{The @option{-E} flag to @command{sudo} guarantees that @code{GUILE_LOAD_PATH} is correctly set such that @command{guix-daemon} and the tools it uses can find the Guile modules they need.}:"
msgstr "Se você estiver hackeando o daemon e seu código de suporte ou se @command{guix-daemon} ainda não estiver em execução no seu sistema, você pode iniciá-lo diretamente da build tree@footnote{O sinalizador @option{-E} para @command{sudo} garante que @code{GUILE_LOAD_PATH} esteja configurado corretamente para que @command{guix-daemon} e as ferramentas que ele usa possam encontrar os módulos Guile necessários.}:"

msgid "$ sudo -E ./pre-inst-env guix-daemon --build-users-group=guixbuild\n"
msgstr "$ sudo -E ./pre-inst-env guix-daemon --build-users-group=guixbuild\n"

msgid "The @command{pre-inst-env} script sets up all the environment variables necessary to support this, including @env{PATH} and @env{GUILE_LOAD_PATH}."
msgstr "O script @command{pre-inst-env} configura todas as variáveis de ambiente necessárias para prover suporte a isso, incluindo @env{PATH} e @env{GUILE_LOAD_PATH}."

msgid "Note that @command{./pre-inst-env guix pull} does @emph{not} upgrade the local source tree; it simply updates the @file{~/.config/guix/current} symlink (@pxref{Invoking guix pull}).  Run @command{git pull} instead if you want to upgrade your local source tree."
msgstr "Observe que @command{./pre-inst-env guix pull} @emph{não} atualiza a área de fontes local; ele simplesmente atualiza a ligação simbólica @file{~/.config/guix/current} (@pxref{Invoking guix pull}). Execute @command{git pull} em vez disso, se você quiser atualizar sua árvore de fontes local."

msgid "Sometimes, especially if you have recently updated your repository, running @command{./pre-inst-env} will print a message similar to the following example:"
msgstr "Às vezes, especialmente se você atualizou seu repositório recentemente, executar @command{./pre-inst-env} imprimirá uma mensagem semelhante ao exemplo a seguir:"

msgid ""
";;; note: source file /home/user/projects/guix/guix/progress.scm\n"
";;;       newer than compiled /home/user/projects/guix/guix/progress.go\n"
msgstr ""
";;; note: source file /home/user/projects/guix/guix/progress.scm\n"
";;;       newer than compiled /home/user/projects/guix/guix/progress.go\n"

msgid "This is only a note and you can safely ignore it.  You can get rid of the message by running @command{make -j4}.  Until you do, Guile will run slightly slower because it will interpret the code instead of using prepared Guile object (@file{.go}) files."
msgstr "Esta é apenas uma nota e você pode ignorá-la com segurança. Você pode se livrar da mensagem executando @command{make -j4}. Até que você faça isso, o Guile será executado um pouco mais devagar porque interpretará o código em vez de usar arquivos de objeto Guile preparados (@file{.go})."

msgid "You can run @command{make} automatically as you work using @command{watchexec} from the @code{watchexec} package.  For example, to build again each time you update a package file, run @samp{watchexec -w gnu/packages -- make -j4}."
msgstr "Você pode executar @command{make} automaticamente enquanto trabalha usando @command{watchexec} do pacote @code{watchexec}. Por exemplo, para compilar novamente cada vez que você atualizar um arquivo de pacote, execute @samp{watchexec -w gnu/packages -- make -j4}."

msgid "Guile Studio"
msgstr "Guile Estúdio"

msgid "First step in your transition to Emacs."
msgstr "Primeiro passo na sua transição para o Emacs."

msgid "Vim and NeoVim"
msgstr "Vim e NeoVim"

msgid "Geiser allows for interactive and incremental development from within Emacs: code compilation and evaluation from within buffers, access to on-line documentation (docstrings), context-sensitive completion, @kbd{M-.} to jump to an object definition, a REPL to try out your code, and more (@pxref{Introduction,,, geiser, Geiser User Manual}).  If you allow Emacs to load the @file{.dir-locals.el} file at the root of the project checkout, it will cause Geiser to automatically add the local Guix sources to the Guile load path."
msgstr "O Geiser permite desenvolvimento interativo e incremental de dentro do Emacs: compilação e avaliação de código de dentro de buffers, acesso à documentação on-line (docstrings), conclusão sensível ao contexto, @kbd{M-.} para pular para uma definição de objeto, um REPL para testar seu código e muito mais (@pxref{Introduction,,, geiser, Manual do Usuário do Geiser}). Se você permitir que o Emacs carregue o arquivo @file{.dir-locals.el} na raiz do checkout do projeto, isso fará com que o Geiser adicione automaticamente as fontes locais do Guix ao caminho de carregamento do Guile."

msgid "To actually edit the code, Emacs already has a neat Scheme mode.  But in addition to that, you must not miss @url{https://www.emacswiki.org/emacs/ParEdit, Paredit}.  It provides facilities to directly operate on the syntax tree, such as raising an s-expression or wrapping it, swallowing or rejecting the following s-expression, etc."
msgstr "Para realmente editar o código, o Emacs já possui um modo Scheme bacana. Mas além disso, você não deve perder @url{https://www.emacswiki.org/emacs/ParEdit, Paredit}. Ele fornece recursos para operar diretamente na árvore sintática, como aumentar ou agrupar uma expressão simbólica (S-expression), engolir ou rejeitar a expressão simbólica seguinte, etc."

msgid "code snippets"
msgstr "trechos de código"

msgid "templates"
msgstr "modelos"

msgid "reducing boilerplate"
msgstr "reduzindo boilerplate"

msgid "We also provide templates for common git commit messages and package definitions in the @file{etc/snippets} directory.  These templates can be used to expand short trigger strings to interactive text snippets. If you use @url{https://joaotavora.github.io/yasnippet/, YASnippet}, you may want to add the @file{etc/snippets/yas} snippets directory to the @var{yas-snippet-dirs} variable.  If you use @url{https://github.com/minad/tempel/, Tempel}, you may want to add the @file{etc/snippets/tempel/*} path to the @var{tempel-path} variable in Emacs."
msgstr "Também fornecemos modelos para mensagens comuns de commit do git e definições de pacotes no diretório @file{etc/snippets}. Esses modelos podem ser usados para expandir sequências curtas de gatilho para trechos de texto interativos. Se você usar @url{https://joaotavora.github.io/yasnippet/, YASnippet}, você pode querer adicionar o diretório de snippets @file{etc/snippets/yas} ao @var{yas-snippet-dirs} variável. Se você usar @url{https://github.com/minad/tempel/, Tempel}, você pode querer adicionar o caminho @file{etc/snippets/tempel/*} à variável @var{tempel-path} no Emacs."

msgid ""
";; @r{Assuming the Guix checkout is in ~/src/guix.}\n"
";; @r{Yasnippet configuration}\n"
"(with-eval-after-load 'yasnippet\n"
"  (add-to-list 'yas-snippet-dirs \"~/src/guix/etc/snippets/yas\"))\n"
";; @r{Tempel configuration}\n"
"(with-eval-after-load 'tempel\n"
"   ;; Ensure tempel-path is a list -- it may also be a string.\n"
"   (unless (listp 'tempel-path)\n"
"     (setq tempel-path (list tempel-path)))\n"
"   (add-to-list 'tempel-path \"~/src/guix/etc/snippets/tempel/*\"))\n"
msgstr ""
";; @r{Assuming the Guix checkout is in ~/src/guix.}\n"
";; @r{Yasnippet configuration}\n"
"(with-eval-after-load 'yasnippet\n"
"  (add-to-list 'yas-snippet-dirs \"~/src/guix/etc/snippets/yas\"))\n"
";; @r{Tempel configuration}\n"
"(with-eval-after-load 'tempel\n"
"   ;; Certifique-se de que tempel-path seja uma lista — também pode ser uma string.\n"
"   (unless (listp 'tempel-path)\n"
"     (setq tempel-path (list tempel-path)))\n"
"   (add-to-list 'tempel-path \"~/src/guix/etc/snippets/tempel/*\"))\n"

msgid "The commit message snippets depend on @url{https://magit.vc/, Magit} to display staged files.  When editing a commit message type @code{add} followed by @kbd{TAB} to insert a commit message template for adding a package; type @code{update} followed by @kbd{TAB} to insert a template for updating a package; type @code{https} followed by @kbd{TAB} to insert a template for changing the home page URI of a package to HTTPS."
msgstr "Os trechos de mensagens de commit dependem de @url{https://magit.vc/, Magit} para exibir arquivos \"staged\". Ao editar uma mensagem de commit, digite @code{add} seguido por @kbd{TAB} para inserir um modelo de mensagem de commit para adicionar um pacote; digite @code{update} seguido por @kbd{TAB} para inserir um modelo para atualizar um pacote; digite @code{https} seguido por @kbd{TAB} para inserir um modelo para alterar a URI da página inicial de um pacote para HTTPS."

msgid "The main snippet for @code{scheme-mode} is triggered by typing @code{package...} followed by @kbd{TAB}.  This snippet also inserts the trigger string @code{origin...}, which can be expanded further.  The @code{origin} snippet in turn may insert other trigger strings ending on @code{...}, which also can be expanded further."
msgstr "O trecho principal para @code{scheme-mode} é acionado digitando @code{package ...} seguido de @kbd{TAB}. Esse trecho também insere a string de acionamento @code{origin...}, que pode ser expandida ainda mais. O trecho @code{origin}, por sua vez, pode inserir outras strings acionadoras que terminam em @code{...}, que também podem ser expandidas."

msgid "insert or update copyright"
msgstr "inserir ou atualizar direitos autorais"

msgid "M-x guix-copyright"
msgstr "M-x guix-copyright"

msgid "M-x copyright-update"
msgstr "M-x copyright-update"

msgid "We additionally provide insertion and automatic update of a copyright in @file{etc/copyright.el}.  You may want to set your full name, mail, and load a file."
msgstr "Além disso, fornecemos inserção e atualização automática de direitos autorais em @file{etc/copyright.el}. Você pode definir seu nome completo, e-mail e carregar um arquivo."

msgid ""
"(setq user-full-name \"Alice Doe\")\n"
"(setq user-mail-address \"alice@@mail.org\")\n"
";; @r{Assuming the Guix checkout is in ~/src/guix.}\n"
"(load-file \"~/src/guix/etc/copyright.el\")\n"
msgstr ""
"(setq user-full-name \"Alice Doe\")\n"
"(setq user-mail-address \"alice@@mail.org\")\n"
";; @r{Supondo que o checkout do Guix esteja em ~/src/guix.}\n"
"(load-file \"~/src/guix/etc/copyright.el\")\n"

msgid "To insert a copyright at the current line invoke @code{M-x guix-copyright}."
msgstr "Para inserir um copyright na linha atual, invoque @code{M-x guix-copyright}."

msgid "To update a copyright you need to specify a @code{copyright-names-regexp}."
msgstr "Para atualizar um copyright você precisa especificar um @code{copyright-names-regexp}."

msgid ""
"(setq copyright-names-regexp\n"
"      (format \"%s <%s>\" user-full-name user-mail-address))\n"
msgstr ""
"(setq copyright-names-regexp\n"
"      (format \"%s <%s>\" user-full-name user-mail-address))\n"

msgid "You can check if your copyright is up to date by evaluating @code{M-x copyright-update}.  If you want to do it automatically after each buffer save then add @code{(add-hook 'after-save-hook 'copyright-update)} in Emacs."
msgstr "Você pode verificar se seus direitos autorais estão atualizados avaliando @code{M-x copyright-update}. Se você quiser fazer isso automaticamente após cada salvamento de buffer, adicione @code{(add-hook 'after-save-hook 'copyright-update)} no Emacs."

msgid "Guile Studio is a pre-configured Emacs with mostly everything you need to start hacking in Guile. If you are not familiar with Emacs it makes the transition easier for you."
msgstr "Guile Studio é um Emacs pré-configurado com praticamente tudo que você precisa para começar a hackear no Guile. Se você não estiver familiarizado com o Emacs, a transição será mais fácil para você."

msgid "guix install guile-studio\n"
msgstr "guix install guile-studio\n"

msgid "Guile Studio comes with Geiser preinstalled and prepared for action."
msgstr "Guile Studio vem com Geiser pré-instalado e preparado para ação."

msgid "guix install vim\n"
msgstr "guix install vim\n"

msgid "If you want to enjoy a similar development experience to that in the perfect setup, you should install several plugins to configure the editor. Vim (and NeoVim) have the equivalent to Paredit, @uref{https://www.vim.org/scripts/script.php?script_id=3998, @code{paredit.vim}}, that will help you with the structural editing of Scheme files (the support for very large files is not great, though)."
msgstr "Se você deseja desfrutar de uma experiência de desenvolvimento semelhante à configuração perfeita, você deve instalar vários plugins para configurar o editor. O Vim (e o NeoVim) têm o equivalente ao Paredit, @uref{https://www.vim.org/scripts/script.php?script_id=3998, @code{paredit.vim}}, que irá ajudá-lo com a estrutura edição de arquivos Scheme (embora o suporte para arquivos muito grandes não seja ótimo)."

msgid "guix install vim-paredit\n"
msgstr "guix install vim-paredit\n"

msgid "We also recommend that you run @code{:set autoindent} so that your code is automatically indented as you type."
msgstr "Também recomendamos que você execute @code{:set autoindent} para que seu código seja recuado automaticamente conforme você digita."

msgid "For the interaction with Git, @uref{https://www.vim.org/scripts/script.php?script_id=2975, @code{fugitive.vim}} is the most commonly used plugin:"
msgstr "Para a interação com Git, @uref{https://www.vim.org/scripts/script.php?script_id=2975, @code{fugitive.vim}} é o plugin mais comumente usado:"

msgid "guix install vim-fugitive\n"
msgstr "guix install vim-fugitive\n"

msgid "And of course if you want to interact with Guix directly from inside of vim, using the built-in terminal emulator, we have our very own @code{guix.vim} package!"
msgstr "E claro, se você quiser interagir com o Guix diretamente de dentro do vim, usando o emulador de terminal integrado, temos nosso próprio pacote @code{guix.vim}!"

msgid "guix install vim-guix-vim\n"
msgstr "guix install vim-guix-vim\n"

msgid "In NeoVim you can even make a similar setup to Geiser using @url{https://conjure.fun/, Conjure} that lets you connect to a running Guile process and inject your code there live (sadly it's not packaged in Guix yet)."
msgstr "No NeoVim você pode até fazer uma configuração semelhante ao Geiser usando @url{https://conjure.fun/, Conjure} que permite conectar-se a um processo Guile em execução e injetar seu código ao vivo (infelizmente ainda não está empacotado no Guix) ."

msgid "structure, of the source tree"
msgstr "estrutura da árvore de origem"

msgid "If you're willing to contribute to Guix beyond packages, or if you'd like to learn how it all fits together, this section provides a guided tour in the code base that you may find useful."
msgstr "Se você estiver disposto a contribuir com o Guix além dos pacotes, ou se quiser aprender como tudo se encaixa, esta seção fornece um tour guiado na base de código que pode ser útil."

msgid "Overall, the Guix source tree contains almost exclusively Guile @dfn{modules}, each of which can be seen as an independent library (@pxref{Modules,,, guile, GNU Guile Reference Manual})."
msgstr "No geral, a árvore de origem do Guix contém quase exclusivamente Guile @dfn{módulos}, cada um dos quais pode ser visto como uma biblioteca independente (@pxref{Modules,,, guile, Manual de Referência do GNU Guile})."

msgid "The following table gives an overview of the main directories and what they contain.  Remember that in Guile, each module name is derived from its file name---e.g., the module in file @file{guix/packages.scm} is called @code{(guix packages)}."
msgstr "A tabela a seguir fornece uma visão geral dos principais diretórios e o que eles contêm. Lembre-se de que no Guile, cada nome de módulo é derivado de seu nome de arquivo---por exemplo, o módulo no arquivo @file{guix/packages.scm} é chamado @code{(guix packages)}."

msgid "guix"
msgstr "guix"

msgid "This is the location of core Guix mechanisms.  To illustrate what is meant by ``core'', here are a few examples, starting from low-level tools and going towards higher-level tools:"
msgstr "Esta é a localização dos mecanismos principais do Guix. Para ilustrar o que significa ``core'', aqui estão alguns exemplos, começando com ferramentas de baixo nível e indo em direção a ferramentas de nível mais alto:"

msgid "(guix store)"
msgstr "(guix store)"

msgid "Connecting to and interacting with the build daemon (@pxref{The Store})."
msgstr "Conectando e interagindo com o daemon de compilação (@pxref{The Store})."

msgid "(guix derivations)"
msgstr "(guix derivations)"

msgid "Creating derivations (@pxref{Derivations})."
msgstr "Criando derivações (@pxref{Derivations})."

msgid "(guix gexps)"
msgstr "(guix gexps)"

msgid "Writing G-expressions (@pxref{G-Expressions})."
msgstr "Escrevendo expressões-G (@pxref{G-Expressions})."

msgid "(guix packages)"
msgstr "(guix packages)"

msgid "Defining packages and origins (@pxref{package Reference})."
msgstr "Definindo pacotes e origens (@pxref{package Reference})."

msgid "(guix download)"
msgstr "(guix download)"

msgid "(guix git-download)"
msgstr "(guix git-download)"

msgid "The @code{url-fetch} and @code{git-fetch} origin download methods (@pxref{origin Reference})."
msgstr "Os métodos de download de origem @code{url-fetch} e @code{git-fetch} (@pxref{origin Reference})."

msgid "(guix swh)"
msgstr "(guix swh)"

msgid "Fetching source code from the @uref{https://archive.softwareheritage.org,Software Heritage archive}."
msgstr "Obtendo código-fonte do @uref{https://archive.softwareheritage.org, arquivo Software Heritage}."

msgid "(guix search-paths)"
msgstr "(guix search-paths)"

msgid "Implementing search paths (@pxref{Search Paths})."
msgstr "Implementando caminhos de pesquisa (@pxref{Search Paths})."

msgid "(guix build-system)"
msgstr "(guix build-system)"

msgid "The build system interface (@pxref{Build Systems})."
msgstr "A interface do sistema de compilação (@pxref{Build Systems})."

msgid "(guix profiles)"
msgstr "(guix profiles)"

msgid "Implementing profiles."
msgstr "Implementando perfis."

msgid "build system, directory structure"
msgstr "sistema de construção, estrutura de diretório"

msgid "guix/build-system"
msgstr "guix/build-system"

msgid "This directory contains specific build system implementations (@pxref{Build Systems}), such as:"
msgstr "Este diretório contém implementações específicas do sistema de compilação (@pxref{Build Systems}), como:"

msgid "(guix build-system gnu)"
msgstr "(guix build-system gnu)"

msgid "the GNU build system;"
msgstr "o sistema de compilação do GNU;"

msgid "(guix build-system cmake)"
msgstr "(guix build-system cmake)"

msgid "the CMake build system;"
msgstr "o sistema de compilação CMake;"

msgid "(guix build-system pyproject)"
msgstr "(guix build-system pyproject)"

msgid "The Python ``pyproject'' build system."
msgstr "O sistema de compilção ``pyproject'' do Python"

msgid "guix/build"
msgstr "guix/build"

msgid "This contains code generally used on the ``build side'' (@pxref{G-Expressions, strata of code}).  This includes code used to build packages or other operating system components, as well as utilities:"
msgstr "Isto contém código geralmente usado no ``lado da construção'' (@pxref{G-Expressions, strata of code}). Isto inclui código usado para construir pacotes ou outros componentes do sistema operacional, assim como utilitários:"

msgid "(guix build utils)"
msgstr "(guix build utils)"

msgid "Utilities for package definitions and more (@pxref{Build Utilities})."
msgstr "Utilitários para definições de pacotes e muito mais (@pxref{Build Utilities})."

msgid "(guix build gnu-build-system)"
msgstr "(guix build gnu-build-system)"

msgid "(guix build cmake-build-system)"
msgstr "(guix build cmake-build-system)"

msgid "(guix build pyproject-build-system)"
msgstr "(guix build pyproject-build-system)"

msgid "Implementation of build systems, and in particular definition of their build phases (@pxref{Build Phases})."
msgstr "Implementação de sistemas de construção e, em particular, definição de suas fases de construção (@pxref{Build Phases})."

msgid "(guix build syscalls)"
msgstr "(guix build syscalls)"

msgid "Interface to the C library and to Linux system calls."
msgstr "Interface para a biblioteca C e para chamadas de sistema Linux."

msgid "command-line tools, as Guile modules"
msgstr "ferramentas de linha de comando, como módulos Guile"

msgid "command modules"
msgstr "módulos de comando"

msgid "guix/scripts"
msgstr "guix/scripts"

msgid "This contains modules corresponding to @command{guix} sub-commands.  For example, the @code{(guix scripts shell)} module exports the @code{guix-shell} procedure, which directly corresponds to the @command{guix shell} command (@pxref{Invoking guix shell})."
msgstr "Isto contém módulos correspondentes aos subcomandos @command{guix}. Por exemplo, o módulo @code{(guix scripts shell)} exporta o procedimento @code{guix-shell}, que corresponde diretamente ao comando @command{guix shell} (@pxref{Invoking guix shell})."

msgid "importer modules"
msgstr "módulos importadores"

msgid "guix/import"
msgstr "guix/import"

msgid "This contains supporting code for the importers and updaters (@pxref{Invoking guix import}, and @pxref{Invoking guix refresh}).  For example, @code{(guix import pypi)} defines the interface to PyPI, which is used by the @command{guix import pypi} command."
msgstr "Isto contém código de suporte para os importadores e atualizadores (@pxref{Invoking guix import} e @pxref{Invoking guix refresh}). Por exemplo, @code{(guix import pypi)} define a interface para PyPI, que é usada pelo comando @command{guix import pypi}."

msgid "The directories we have seen so far all live under @file{guix/}.  The other important place is the @file{gnu/} directory, which contains primarily package definitions as well as libraries and tools for Guix System (@pxref{System Configuration}) and Guix Home (@pxref{Home Configuration}), all of which build upon functionality provided by @code{(guix @dots{})} modules@footnote{For this reason, @code{(guix @dots{})} modules must generally not depend on @code{(gnu @dots{})} modules, with notable exceptions: @code{(guix build-system @dots{})} modules may look up packages at run time---e.g., @code{(guix build-system cmake)} needs to access the @code{cmake} variable at run time---, @code{(guix scripts @dots{})} often rely on @code{(gnu @dots{})} modules, and the same goes for some of the @code{(guix import @dots{})} modules.}."
msgstr "Todos os diretórios que vimos até agora estão em @file{guix/}. O outro lugar importante é o diretório @file{gnu/}, que contém principalmente definições de pacotes, bem como bibliotecas e ferramentas para Guix System (@pxref{System Configuration}) e Guix Home (@pxref{Home Configuration}), todos os quais se baseiam na funcionalidade fornecida pelos módulos @code{(guix @dots{})}@footnote{Por esse motivo, os módulos @code{(guix @dots{})} geralmente não devem depender dos módulos @code{(gnu @dots{})}, com exceções notáveis: os módulos @code{(guix build-system @dots{})} podem procurar pacotes em tempo de execução --- por exemplo, @code{(guix build-system cmake)} precisa acessar a variável @code{cmake} em tempo de execução ---, @code{(guix scripts @dots{})} geralmente dependem dos módulos @code{(gnu @dots{})}, e o mesmo vale para alguns dos módulos @code{(guix import @dots{})} módulos.}."

msgid "package modules"
msgstr "módulos de pacote"

msgid "gnu/packages"
msgstr "gnu/packages"

msgid "This is by far the most crowded directory of the source tree: it contains @dfn{package modules} that export package definitions (@pxref{Package Modules}).  A few examples:"
msgstr "Este é de longe o diretório mais lotado da árvore de fontes: ele contém @dfn{package modules} que exportam definições de pacotes (@pxref{Package Modules}). Alguns exemplos:"

msgid "(gnu packages base)"
msgstr "(gnu packages base)"

msgid "Module providing ``base'' packages: @code{glibc}, @code{coreutils}, @code{grep}, etc."
msgstr "Módulo que fornece pacotes ``base'': @code{glibc}, @code{coreutils}, @code{grep}, etc."

msgid "(gnu packages guile)"
msgstr "(gnu packages guile)"

msgid "Guile and core Guile packages."
msgstr "Guile e pacotes principais do Guile."

msgid "(gnu packages linux)"
msgstr "(gnu packages linux)"

msgid "The Linux-libre kernel and related packages."
msgstr "O kernel Linux-libre e pacotes relacionados."

msgid "(gnu packages python)"
msgstr "(gnu packages python)"

msgid "Python and core Python packages."
msgstr "Python e pacotes principais do Python."

msgid "(gnu packages python-xyz)"
msgstr "(gnu packages python-xyz)"

msgid "Miscellaneous Python packages (we were not very creative)."
msgstr "Pacotes Python diversos (não fomos muito criativos)."

msgid "In any case, you can jump to a package definition using @command{guix edit} (@pxref{Invoking guix edit}) and view its location with @command{guix show} (@pxref{Invoking guix package})."
msgstr "Em qualquer caso, você pode pular para uma definição de pacote usando @command{guix edit} (@pxref{Invoking guix edit}) e visualizar sua localização com @command{guix show} (@pxref{Invoking guix package})."

msgid "search-patches"
msgstr "search-patches"

msgid "gnu/packages/patches"
msgstr "gnu/packages/patches"

msgid "This directory contains patches applied against packages and obtained using the @code{search-patches} procedure."
msgstr "Este diretório contém patches aplicados aos pacotes e obtidos usando o procedimento @code{search-patches}."

msgid "gnu/services"
msgstr "gnu/services"

msgid "This contains service definitions, primarily for Guix System (@pxref{Services}) but some of them are adapted and reused for Guix Home as we will see below.  Examples:"
msgstr "Isto contém definições de serviço, principalmente para Guix System (@pxref{Services}), mas algumas delas são adaptadas e reutilizadas para Guix Home, como veremos abaixo. Exemplos:"

msgid "(gnu services)"
msgstr "(gnu services)"

msgid "The service framework itself, which defines the service and service type data types (@pxref{Service Composition})."
msgstr "A estrutura do serviço em si, que define os tipos de dados do serviço e do tipo de serviço (@pxref{Service Composition})."

msgid "(gnu services base)"
msgstr "(gnu services base)"

msgid "``Base'' services (@pxref{Base Services})."
msgstr "Serviços ``básicos'' (@pxref{Base Services})."

msgid "(gnu services desktop)"
msgstr "(gnu services desktop)"

msgid "``Desktop'' services (@pxref{Desktop Services})."
msgstr "Serviços ``desktop'' (@pxref{Desktop Services})."

msgid "(gnu services shepherd)"
msgstr "(gnu services shepherd)"

msgid "Support for Shepherd services (@pxref{Shepherd Services})."
msgstr "Apoio aos serviços Shepherd (@pxref{Shepherd Services})."

msgid "You can jump to a service definition using @command{guix system edit} and view its location with @command{guix system search} (@pxref{Invoking guix system})."
msgstr "Você pode pular para uma definição de serviço usando @command{guix system edit} e visualizar sua localização com @command{guix system search} (@pxref{Invoking guix system})."

msgid "gnu/system"
msgstr "gnu/system"

msgid "These are core Guix System modules, such as:"
msgstr "Estes são os principais módulos do sistema Guix, como:"

msgid "(gnu system)"
msgstr "(gnu system)"

msgid "Defines @code{operating-system} (@pxref{operating-system Reference})."
msgstr "Define @code{operating-system} (@pxref{operating-system Reference})."

msgid "(gnu system file-systems)"
msgstr "(gnu system file-systems)"

msgid "Defines @code{file-system} (@pxref{File Systems})."
msgstr "Define @code{file-system} (@pxref{File Systems})."

msgid "(gnu system mapped-devices)"
msgstr "(gnu system mapped-devices)"

msgid "Defines @code{mapped-device} (@pxref{Mapped Devices})."
msgstr "Define @code{mapped-device} (@pxref{Mapped Devices})."

msgid "gnu/build"
msgstr "gnu/build"

msgid "These are modules that are either used on the ``build side'' when building operating systems or packages, or at run time by operating systems."
msgstr "Esses são módulos que são usados no ``lado da compilação'' ao criar sistemas operacionais ou pacotes, ou em tempo de execução pelos sistemas operacionais."

msgid "(gnu build accounts)"
msgstr "(gnu build accounts)"

msgid "Creating @file{/etc/passwd}, @file{/etc/shadow}, etc. (@pxref{User Accounts})."
msgstr "Criando @file{/etc/passwd}, @file{/etc/shadow}, etc. (@pxref{User Accounts})."

msgid "(gnu build activation)"
msgstr "(gnu build activation)"

msgid "Activating an operating system at boot time or reconfiguration time."
msgstr "Ativar um sistema operacional no momento da inicialização ou da reconfiguração."

msgid "(gnu build file-systems)"
msgstr "(gnu build file-systems)"

msgid "Searching, checking, and mounting file systems."
msgstr "Pesquisar, verificar e montar sistemas de arquivos."

msgid "(gnu build linux-boot)"
msgstr "(gnu build linux-boot)"

msgid "(gnu build hurd-boot)"
msgstr "(gnu build hurd-boot)"

msgid "Booting GNU/Linux and GNU/Hurd operating systems."
msgstr "Inicializando sistemas operacionais GNU/Linux e GNU/Hurd."

msgid "(gnu build linux-initrd)"
msgstr "(gnu build linux-initrd)"

msgid "Creating a Linux initial RAM disk (@pxref{Initial RAM Disk})."
msgstr "Criando um disco RAM inicial do Linux (@pxref{Initial RAM Disk})."

msgid "gnu/home"
msgstr "gnu/home"

msgid "This contains all things Guix Home (@pxref{Home Configuration}); examples:"
msgstr "Isso contém todas as coisas do Guix Home (@pxref{Home Configuration}); exemplos:"

msgid "(gnu home services)"
msgstr "(gnu home services)"

msgid "Core services such as @code{home-files-service-type}."
msgstr "Serviços principais como @code{home-files-service-type}."

msgid "(gnu home services ssh)"
msgstr "(gnu home services ssh)"

msgid "SSH-related services (@pxref{Secure Shell})."
msgstr "Serviços relacionados a SSH (@pxref{Secure Shell})."

msgid "gnu/installer"
msgstr "gnu/installer"

msgid "This contains the text-mode graphical system installer (@pxref{Guided Graphical Installation})."
msgstr "Isso contém o instalador do sistema gráfico em modo texto (@pxref{Guided Graphical Installation})."

msgid "gnu/machine"
msgstr "gnu/machine"

msgid "These are the @dfn{machine abstractions} used by @command{guix deploy} (@pxref{Invoking guix deploy})."
msgstr "Estas são as @dfn{abstrações de máquina} usadas por @command{guix deploy} (@pxref{Invoking guix deploy})."

msgid "gnu/tests"
msgstr "gnu/tests"

msgid "This contains system tests---tests that spawn virtual machines to check that system services work as expected (@pxref{Running the Test Suite})."
msgstr "Isso contém testes de sistema — testes que geram máquinas virtuais para verificar se os serviços do sistema funcionam conforme o esperado (@pxref{Running the Test Suite})."

msgid "Last, there's also a few directories that contain files that are @emph{not} Guile modules:"
msgstr "Por fim, há também alguns diretórios que contêm arquivos que não são módulos Guile:"

msgid "nix"
msgstr "nix"

msgid "This is the C++ implementation of @command{guix-daemon}, inherited from Nix (@pxref{Invoking guix-daemon})."
msgstr "Esta é a implementação C++ do @command{guix-daemon}, herdada do Nix (@pxref{Invoking guix-daemon})."

msgid "tests"
msgstr "tests"

msgid "These are unit tests, each file corresponding more or less to one module, in particular @code{(guix @dots{})} modules (@pxref{Running the Test Suite})."
msgstr "Esses são testes unitários, cada arquivo correspondendo mais ou menos a um módulo, em particular os módulos @code{(guix @dots{})} (@pxref{Running the Test Suite})."

msgid "doc"
msgstr "doc"

msgid "This is the documentation in the form of Texinfo files: this manual and the Cookbook.  @xref{Writing a Texinfo File,,, texinfo, GNU Texinfo}, for information on Texinfo markup language."
msgstr "Esta é a documentação na forma de arquivos Texinfo: este manual e o Livro de receitas. @xref{Writing a Texinfo File,,, texinfo, GNU Texinfo}, para informações sobre a linguagem de marcação Texinfo."

msgid "po"
msgstr "po"

msgid "This is the location of translations of Guix itself, of package synopses and descriptions, of the manual, and of the cookbook.  Note that @file{.po} files that live here are pulled directly from Weblate (@pxref{Translating Guix})."
msgstr "Este é o local das traduções do próprio Guix, das sinopses e descrições dos pacotes, do manual e do livro de receitas. Note que os arquivos @file{.po} que vivem aqui são retirados diretamente do Weblate (@pxref{Translating Guix})."

msgid "etc"
msgstr "etc"

msgid "Miscellaneous files: shell completions, support for systemd and other init systems, Git hooks, etc."
msgstr "Arquivos diversos: conclusões de shell, suporte para systemd e outros sistemas init, ganchos do Git, etc."

msgid "With all this, a fair chunk of your operating system is at your fingertips! Beyond @command{grep} and @command{git grep}, @pxref{The Perfect Setup} on how to navigate code from your editor, and @pxref{Using Guix Interactively} for information on how to use Scheme modules interactively.  Enjoy!"
msgstr "Com tudo isso, uma boa parte do seu sistema operacional está na ponta dos seus dedos! Além de @command{grep} e @command{git grep}, @pxref{The Perfect Setup} sobre como navegar no código do seu editor e @pxref{Using Guix Interactively} para obter informações sobre como usar módulos Scheme interativamente. Aproveite!"

msgid "packages, creating"
msgstr "pacotes, criação"

msgid "The GNU distribution is nascent and may well lack some of your favorite packages.  This section describes how you can help make the distribution grow."
msgstr "A distribuição do GNU é incipiente e pode muito bem não ter alguns dos seus pacotes favoritos. Esta seção descreve como você pode ajudar a fazer a distribuição crescer."

msgid "Free software packages are usually distributed in the form of @dfn{source code tarballs}---typically @file{tar.gz} files that contain all the source files.  Adding a package to the distribution means essentially two things: adding a @dfn{recipe} that describes how to build the package, including a list of other packages required to build it, and adding @dfn{package metadata} along with that recipe, such as a description and licensing information."
msgstr "Pacotes de software livre geralmente são distribuídos na forma de @dfn{tarballs de código-fonte} -- geralmente arquivos @file{tar.gz} que contêm todos os arquivos fonte. Adicionar um pacote à distribuição significa essencialmente duas coisas: adicionar uma @dfn{receita} que descreve como criar o pacote, incluindo uma lista de outros pacotes necessários para compilá-lo e adicionar @dfn{metadados de pacote} junto com essa receita, como uma descrição e informações de licenciamento."

msgid "In Guix all this information is embodied in @dfn{package definitions}.  Package definitions provide a high-level view of the package.  They are written using the syntax of the Scheme programming language; in fact, for each package we define a variable bound to the package definition, and export that variable from a module (@pxref{Package Modules}).  However, in-depth Scheme knowledge is @emph{not} a prerequisite for creating packages.  For more information on package definitions, @pxref{Defining Packages}."
msgstr "No Guix, todas essas informações estão incorporadas em @dfn{configurações de pacote}. As definições de pacote fornecem uma visão de alto nível do pacote. Elas são escritas usando a sintaxe da linguagem de programação Scheme; de fato, para cada pacote, definimos uma variável vinculada à definição do pacote e exportamos essa variável de um módulo (@pxref{Package Modules}). No entanto, o conhecimento profundo de Scheme @emph{não} é um pré-requisito para a criação de pacotes. Para mais informações sobre definições de pacotes, @pxref{Defining Packages}."

msgid "Once a package definition is in place, stored in a file in the Guix source tree, it can be tested using the @command{guix build} command (@pxref{Invoking guix build}).  For example, assuming the new package is called @code{gnew}, you may run this command from the Guix build tree (@pxref{Running Guix Before It Is Installed}):"
msgstr "Quando uma definição de pacote está em vigor, armazenada em um arquivo na árvore de fontes do Guix, ela pode ser testada usando o comando @command{guix build} (@pxref{Invoking guix build}). Por exemplo, supondo que o novo pacote seja chamado @code{gnew}, você pode executar este comando na árvore de construção do Guix (@pxref{Running Guix Before It Is Installed}):"

msgid "./pre-inst-env guix build gnew --keep-failed\n"
msgstr "./pre-inst-env guix build gnew --keep-failed\n"

msgid "Using @code{--keep-failed} makes it easier to debug build failures since it provides access to the failed build tree.  Another useful command-line option when debugging is @code{--log-file}, to access the build log."
msgstr "O uso de @code{--keep-failed} facilita a depuração de falhas de compilação, pois fornece acesso à árvore de compilação com falha. Outra opção útil da linha de comando ao depurar é @code{--log-file}, para acessar o log de compilação."

msgid "If the package is unknown to the @command{guix} command, it may be that the source file contains a syntax error, or lacks a @code{define-public} clause to export the package variable.  To figure it out, you may load the module from Guile to get more information about the actual error:"
msgstr "Se o pacote for desconhecido para o comando @command{guix}, pode ser que o arquivo fonte contenha um erro de sintaxe ou não tenha uma cláusula @code{define-public} para exportar a variável do pacote. Para descobrir isso, você pode carregar o módulo do Guile para obter mais informações sobre o erro real:"

msgid "./pre-inst-env guile -c '(use-modules (gnu packages gnew))'\n"
msgstr "./pre-inst-env guile -c '(use-modules (gnu packages gnew))'\n"

msgid "Once your package builds correctly, please send us a patch (@pxref{Submitting Patches}).  Well, if you need help, we will be happy to help you too.  Once the patch is committed in the Guix repository, the new package automatically gets built on the supported platforms by @url{https://@value{SUBSTITUTE-SERVER-1}, our continuous integration system}."
msgstr "Assim que seu pacote for compilado corretamente, envie-nos um patch (@pxref{Submitting Patches}). Bem, se precisar de ajuda, ficaremos felizes em ajudá-lo também. Depois que o patch é confirmado no repositório Guix, o novo pacote é compilado automaticamente nas plataformas suportadas por @url{https://@value{SUBSTITUTE-SERVER-1}, nosso sistema de integração contínua}."

msgid "substituter"
msgstr "substituidor"

msgid "Users can obtain the new package definition simply by running @command{guix pull} (@pxref{Invoking guix pull}).  When @code{@value{SUBSTITUTE-SERVER-1}} is done building the package, installing the package automatically downloads binaries from there (@pxref{Substitutes}).  The only place where human intervention is needed is to review and apply the patch."
msgstr "Os usuários podem obter a nova definição de pacote simplesmente executando @command{guix pull} (@pxref{Invoking guix pull}). Quando @code{@value{SUBSTITUTE-SERVER-1}} termina de construir o pacote, a instalação do pacote baixa automaticamente os binários de lá (@pxref{Substitutes}). O único lugar onde a intervenção humana é necessária é para revisar e aplicar o patch."

msgid "Software Freedom"
msgstr "Liberdade de software"

msgid "What may go into the distribution."
msgstr "O que pode ir na distribuição."

msgid "Package Naming"
msgstr "Nomeando um pacote"

msgid "What's in a name?"
msgstr "Que há em um nome?"

msgid "Version Numbers"
msgstr "Números de versão"

msgid "When the name is not enough."
msgstr "Quando o nome não é suficiente."

msgid "Synopses and Descriptions"
msgstr "Sinopses e descrições"

msgid "Helping users find the right package."
msgstr "Ajudando usuários a localizar o pacote certo."

msgid "Snippets versus Phases"
msgstr "Snippets versus Phases"

msgid "Whether to use a snippet, or a build phase."
msgstr "Seja para usar um snippet ou uma fase de construção."

msgid "Cyclic Module Dependencies"
msgstr "Dependências do módulo cíclico"

msgid "Going full circle."
msgstr "Fazendo um círculo completo."

msgid "Bulk Updates"
msgstr "Atualizações em massa"

msgid "This Little Maneuver's Gonna Cost Us 51 Years."
msgstr "Essa pequena manobra nos custará 51 anos."

msgid "Emacs Packages"
msgstr "Pacotes Emacs"

msgid "Your Elisp fix."
msgstr "Sua correção Elisp."

msgid "Python Modules"
msgstr "Módulos Python"

msgid "A touch of British comedy."
msgstr "Um toque de comédia britânica."

msgid "Perl Modules"
msgstr "Módulos Perl"

msgid "Little pearls."
msgstr "Pequenas pérolas."

msgid "Java Packages"
msgstr "Pacotes Java"

msgid "Coffee break."
msgstr "Parada para o café."

msgid "Rust Crates"
msgstr "Rust Crates"

msgid "Beware of oxidation."
msgstr "Cuidado com a oxidação."

msgid "Elm Packages"
msgstr "Pacotes Elm"

msgid "Trees of browser code"
msgstr "Árvores de código do navegador"

msgid "Fonts"
msgstr "Fontes"

msgid "Fond of fonts."
msgstr "Vício em fontes."

msgid "free software"
msgstr "software livre"

msgid "The GNU operating system has been developed so that users can have freedom in their computing.  GNU is @dfn{free software}, meaning that users have the @url{https://www.gnu.org/philosophy/free-sw.html,four essential freedoms}: to run the program, to study and change the program in source code form, to redistribute exact copies, and to distribute modified versions.  Packages found in the GNU distribution provide only software that conveys these four freedoms."
msgstr "O sistema operacional GNU foi desenvolvido para que os usuários possam ter liberdade em sua computação. GNU é @dfn{software livre}, o que significa que os usuários têm a @url{https://www.gnu.org/philosophy/free-sw.html,quatro liberdades essenciais}: executar o programa, estudar e alterar o programa em forma de código-fonte, para redistribuir cópias exatas e para distribuir versões modificadas. Os pacotes encontrados na distribuição GNU fornecem apenas softwares que transmitem essas quatro liberdades."

msgid "In addition, the GNU distribution follow the @url{https://www.gnu.org/distros/free-system-distribution-guidelines.html,free software distribution guidelines}.  Among other things, these guidelines reject non-free firmware, recommendations of non-free software, and discuss ways to deal with trademarks and patents."
msgstr "Além disso, a distribuição GNU segue o @url{https://www.gnu.org/distros/free-system-distribution-guidelines.html,diretrizes de distribuição de software livre}. Entre outras coisas, estas diretrizes rejeitam firmware não-livre, recomendações de software não-livre e discutem formas de lidar com marcas registradas e patentes."

msgid "Some otherwise free upstream package sources contain a small and optional subset that violates the above guidelines, for instance because this subset is itself non-free code.  When that happens, the offending items are removed with appropriate patches or code snippets in the @code{origin} form of the package (@pxref{Defining Packages}).  This way, @code{guix build --source} returns the ``freed'' source rather than the unmodified upstream source."
msgstr "Algumas fontes de pacotes upstream livres de outra forma contêm um subconjunto pequeno e opcional que viola as diretrizes acima, por exemplo, porque esse subconjunto é ele próprio um código não livre. Quando isso acontece, os itens incorretos são removidos com patches ou trechos de código apropriados no formato @code{origin} do pacote (@pxref{Defining Packages}). Dessa forma, o @code{guix build --source} retorna a fonte ``lançada'' em vez da fonte upstream não modificada."

msgid "package name"
msgstr "nome de pacote"

msgid "A package actually has two names associated with it.  First, there is the name of the @emph{Scheme variable}, the one following @code{define-public}.  By this name, the package can be made known in the Scheme code, for instance as input to another package.  Second, there is the string in the @code{name} field of a package definition.  This name is used by package management commands such as @command{guix package} and @command{guix build}."
msgstr "Um pacote na verdade tem dois nomes associados a ele. Primeiro, há o nome da @emph{variável Scheme}, a que segue @code{define-public}. Por esse nome, o pacote pode ser tornado conhecido no código Scheme, por exemplo, como entrada para outro pacote. Segundo, há a string no campo @code{name} de uma definição de pacote. Esse nome é usado por comandos de gerenciamento de pacotes, como @command{guix package} e @command{guix build}."

msgid "Both are usually the same and correspond to the lowercase conversion of the project name chosen upstream, with underscores replaced with hyphens.  For instance, GNUnet is available as @code{gnunet}, and SDL_net as @code{sdl-net}."
msgstr "Ambos são geralmente iguais e correspondem à conversão em minúscula do nome do projeto escolhido a montante, com os sublinhados substituídos por hífenes. Por exemplo, o GNUnet está disponível como @code{gnunet} e SDL_net como @code{sdl-net}."

msgid "A noteworthy exception to this rule is when the project name is only a single character, or if an older maintained project with the same name already exists---regardless of whether it has already been packaged for Guix.  Use common sense to make such names unambiguous and meaningful.  For example, Guix's package for the shell called ``s'' upstream is @code{s-shell} and @emph{not} @code{s}.  Feel free to ask your fellow hackers for inspiration."
msgstr "Uma exceção digna de nota a esta regra é quando o nome do projeto é apenas um único caractere, ou se já existe um projeto mantido mais antigo com o mesmo nome - independentemente de já ter sido empacotado para Guix. Use o bom senso para tornar esses nomes inequívocos e significativos. Por exemplo, o pacote do Guix para o shell chamado ``s'' upstream é @code{s-shell} e @emph{não} @code{s}. Sinta-se à vontade para pedir inspiração a seus colegas hackers."

msgid "We do not add @code{lib} prefixes for library packages, unless these are already part of the official project name.  But @pxref{Python Modules} and @ref{Perl Modules} for special rules concerning modules for the Python and Perl languages."
msgstr "Não adicionamos prefixos @code{lib} para pacotes de bibliotecas, a menos que eles já façam parte do nome oficial do projeto. Mas @pxref{Python Modules} e @ref{Perl Modules} para regras especiais relativas a módulos para as linguagens Python e Perl."

msgid "Font package names are handled differently, @pxref{Fonts}."
msgstr "Nomes de pacote de fontes são lidados de forma diferente. @xref{Fonts}."

msgid "package version"
msgstr "versão de pacote"

msgid "We usually package only the latest version of a given free software project.  But sometimes, for instance for incompatible library versions, two (or more) versions of the same package are needed.  These require different Scheme variable names.  We use the name as defined in @ref{Package Naming} for the most recent version; previous versions use the same name, suffixed by @code{-} and the smallest prefix of the version number that may distinguish the two versions."
msgstr "Geralmente, empacotamos apenas a versão mais recente de um determinado projeto de software livre. Mas, às vezes, por exemplo, para versões incompatíveis de bibliotecas, são necessárias duas (ou mais) versões do mesmo pacote. Isso requer nomes de variáveis Scheme diferentes. Usamos o nome como definido em @ref{Package Naming} para a versão mais recente; as versões anteriores usam o mesmo nome, com o sufixo @code{-} e o menor prefixo do número da versão que pode distinguir as duas versões."

msgid "The name inside the package definition is the same for all versions of a package and does not contain any version number."
msgstr "O nome dentro da definição do pacote é o mesmo para todas as versões de um pacote e não contém nenhum número de versão."

msgid "For instance, the versions 2.24.20 and 3.9.12 of GTK+ may be packaged as follows:"
msgstr "Por exemplo, as versões 2.24.20 e 3.9.12 do GTK podem ser empacotados da seguinte forma:"

msgid ""
"(define-public gtk+\n"
"  (package\n"
"    (name \"gtk+\")\n"
"    (version \"3.9.12\")\n"
"    ...))\n"
"(define-public gtk+-2\n"
"  (package\n"
"    (name \"gtk+\")\n"
"    (version \"2.24.20\")\n"
"    ...))\n"
msgstr ""
"(define-public gtk+\n"
"  (package\n"
"    (name \"gtk+\")\n"
"    (version \"3.9.12\")\n"
"    ...))\n"
"(define-public gtk+-2\n"
"  (package\n"
"    (name \"gtk+\")\n"
"    (version \"2.24.20\")\n"
"    ...))\n"

msgid "If we also wanted GTK+ 3.8.2, this would be packaged as"
msgstr "Se também quiséssemos GTK 3.8.2, este seria empacotado como"

msgid ""
"(define-public gtk+-3.8\n"
"  (package\n"
"    (name \"gtk+\")\n"
"    (version \"3.8.2\")\n"
"    ...))\n"
msgstr ""
"(define-public gtk+-3.8\n"
"  (package\n"
"    (name \"gtk+\")\n"
"    (version \"3.8.2\")\n"
"    ...))\n"

msgid "version number, for VCS snapshots"
msgstr "número de versão, para snapshots de VCS"

msgid "Occasionally, we package snapshots of upstream's version control system (VCS) instead of formal releases.  This should remain exceptional, because it is up to upstream developers to clarify what the stable release is.  Yet, it is sometimes necessary.  So, what should we put in the @code{version} field?"
msgstr "Ocasionalmente, empacotamos snapshots do sistema de controle de versão (VCS) do upstream em vez de lançamentos formais. Isso deve permanecer excepcional, porque cabe aos desenvolvedores upstream esclarecer qual é a versão estável. No entanto, às vezes é necessário. Então, o que devemos colocar no campo @code{version}?"

msgid "Clearly, we need to make the commit identifier of the VCS snapshot visible in the version string, but we also need to make sure that the version string is monotonically increasing so that @command{guix package --upgrade} can determine which version is newer.  Since commit identifiers, notably with Git, are not monotonically increasing, we add a revision number that we increase each time we upgrade to a newer snapshot.  The resulting version string looks like this:"
msgstr "Claramente, precisamos tornar o identificador de commit do snapshot VCS visível na string de versão, mas também precisamos garantir que a string de versão esteja aumentando monotonicamente para que o @command{guix package --upgrade} possa determinar qual versão é mais recente. Como os identificadores de commit, principalmente com o Git, não estão aumentando monotonicamente, adicionamos um número de revisão que aumentamos cada vez que atualizamos para um snapshot mais recente. A sequência da versão resultante é assim:"

msgid ""
"2.0.11-3.cabba9e\n"
"  ^    ^    ^\n"
"  |    |    `-- upstream commit ID\n"
"  |    |\n"
"  |    `--- Guix package revision\n"
"  |\n"
"latest upstream version\n"
msgstr ""
"2.0.11-3.cabba9e\n"
"  ^    ^    ^\n"
"  |    |    `-- ID do commit do upstream\n"
"  |    |\n"
"  |    `--- revisão do pacote do Guix\n"
"  |\n"
"versão mais recente do upstream\n"

msgid "It is a good idea to strip commit identifiers in the @code{version} field to, say, 7 digits.  It avoids an aesthetic annoyance (assuming aesthetics have a role to play here) as well as problems related to OS limits such as the maximum shebang length (127 bytes for the Linux kernel).  There are helper functions for doing this for packages using @code{git-fetch} or @code{hg-fetch} (see below).  It is best to use the full commit identifiers in @code{origin}s, though, to avoid ambiguities.  A typical package definition may look like this:"
msgstr "É uma boa ideia reduzir os identificadores de commit no campo @code{version} para, digamos, 7 dígitos. Isso evita um incômodo estético (assumindo que a estética tenha um papel a desempenhar aqui), bem como problemas relacionados aos limites do sistema operacional, como o comprimento máximo do shebang (127 bytes para o kernel Linux). Existem funções auxiliares para fazer isso para pacotes usando @code{git-fetch} ou @code{hg-fetch} (veja abaixo). Porém, é melhor usar os identificadores de commit completos em @code{origin}s para evitar ambiguidades. Uma definição típica de pacote pode ser assim:"

msgid ""
"(define my-package\n"
"  (let ((commit \"c3f29bc928d5900971f65965feaae59e1272a3f7\")\n"
"        (revision \"1\"))          ;Guix package revision\n"
"    (package\n"
"      (version (git-version \"0.9\" revision commit))\n"
"      (source (origin\n"
"                (method git-fetch)\n"
"                (uri (git-reference\n"
"                      (url \"git://example.org/my-package.git\")\n"
"                      (commit commit)))\n"
"                (sha256 (base32 \"1mbikn@dots{}\"))\n"
"                (file-name (git-file-name name version))))\n"
"      ;; @dots{}\n"
"      )))\n"
msgstr ""
"(define meu-pacote\n"
"  (let ((commit \"c3f29bc928d5900971f65965feaae59e1272a3f7\")\n"
"        (revision \"1\"))          ;revisão do pacote do Guix\n"
"    (package\n"
"      (version (git-version \"0.9\" revision commit))\n"
"      (source (origin\n"
"                (method git-fetch)\n"
"                (uri (git-reference\n"
"                      (url \"git://example.org/meu-pacote.git\")\n"
"                      (commit commit)))\n"
"                (sha256 (base32 \"1mbikn@dots{}\"))\n"
"                (file-name (git-file-name name version))))\n"
"      ;; @dots{}\n"
"      )))\n"

msgid "{Procedure} git-version @var{VERSION} @var{REVISION} @var{COMMIT}"
msgstr "{Procedimento} git-version @var{VERSION} @var{REVISION} @var{COMMIT}"

msgid "Return the version string for packages using @code{git-fetch}."
msgstr "Retorne a string de versão para pacotes usando @code{git-fetch}."

msgid ""
"(git-version \"0.2.3\" \"0\" \"93818c936ee7e2f1ba1b315578bde363a7d43d05\")\n"
"@result{} \"0.2.3-0.93818c9\"\n"
msgstr ""
"(git-version \"0.2.3\" \"0\" \"93818c936ee7e2f1ba1b315578bde363a7d43d05\")\n"
"@result{} \"0.2.3-0.93818c9\"\n"

msgid "{Procedure} hg-version @var{VERSION} @var{REVISION} @var{CHANGESET}"
msgstr "{Procedimento} hg-version @var{VERSION} @var{REVISION} @var{CHANGESET}"

msgid "Return the version string for packages using @code{hg-fetch}.  It works in the same way as @code{git-version}."
msgstr "Retorne a string de versão para pacotes usando @code{hg-fetch}. Funciona da mesma forma que @code{git-version}."

msgid "package description"
msgstr "descrição do pacote"

msgid "package synopsis"
msgstr "sinopse do pacote"

msgid "As we have seen before, each package in GNU@tie{}Guix includes a synopsis and a description (@pxref{Defining Packages}).  Synopses and descriptions are important: They are what @command{guix package --search} searches, and a crucial piece of information to help users determine whether a given package suits their needs.  Consequently, packagers should pay attention to what goes into them."
msgstr "Como vimos anteriormente, cada pacote no GNU@tie{}Guix inclui uma sinopse e uma descrição (@pxref{Defining Packages}). Sinopses e descrições são importantes: são o que o @command{guix package --search} pesquisa e uma informação crucial para ajudar os usuários a determinar se um determinado pacote atende às suas necessidades. Consequentemente, os empacotadores devem prestar atenção ao que entra neles."

msgid "Synopses must start with a capital letter and must not end with a period.  They must not start with ``a'' or ``the'', which usually does not bring anything; for instance, prefer ``File-frobbing tool'' over ``A tool that frobs files''.  The synopsis should say what the package is---e.g., ``Core GNU utilities (file, text, shell)''---or what it is used for---e.g., the synopsis for GNU@tie{}grep is ``Print lines matching a pattern''."
msgstr "As sinopses devem começar com uma letra maiúscula e não devem terminar com um ponto. Elas não devem começar com ``a'' ou ``the'', que geralmente não traz nada; por exemplo, prefira ``Tool-frobbing tool'' em vez de ``A tool that frobs files''. A sinopse deve dizer o que é o pacote -- por exemplo, ``Core GNU utilities (file, text, shell)'' -- ou para que é usado -- por exemplo, a sinopse do GNU@tie{}grep é ``Print lines matching a pattern''."

msgid "Keep in mind that the synopsis must be meaningful for a very wide audience.  For example, ``Manipulate alignments in the SAM format'' might make sense for a seasoned bioinformatics researcher, but might be fairly unhelpful or even misleading to a non-specialized audience.  It is a good idea to come up with a synopsis that gives an idea of the application domain of the package.  In this example, this might give something like ``Manipulate nucleotide sequence alignments'', which hopefully gives the user a better idea of whether this is what they are looking for."
msgstr "Lembre-se de que a sinopse deve ser significativa para um público muito amplo. Por exemplo, ``Manipulate alignments in the SAM format'' pode fazer sentido para um pesquisador experiente em bioinformática, mas pode ser bastante inútil ou até enganoso para um público não especializado. É uma boa ideia apresentar uma sinopse que dê uma ideia do domínio do aplicativo do pacote. Neste exemplo, isso pode fornecer algo como ``Manipulate nucleotide sequence alignments'', o que, esperançosamente, dá ao usuário uma melhor ideia de se é isso que eles estão procurando."

msgid "Descriptions should take between five and ten lines.  Use full sentences, and avoid using acronyms without first introducing them.  Please avoid marketing phrases such as ``world-leading'', ``industrial-strength'', and ``next-generation'', and avoid superlatives like ``the most advanced''---they are not helpful to users looking for a package and may even sound suspicious.  Instead, try to be factual, mentioning use cases and features."
msgstr "Descrições devem levar entre cinco e dez linhas. Use sentenças completas e evite usar acrônimos sem primeiro apresentá-los. Por favor, evite frases de marketing como ``inovação mundial'', ``força industrial'' e ``próxima geração'', e evite superlativos como ``a mais avançada'' -- eles não ajudam o usuário procurando por um pacote e podem atém parece suspeito. Em vez idsso, tente se ater aos fatos, mencionando casos de uso e recursos."

msgid "Texinfo markup, in package descriptions"
msgstr "Marcação Texinfo, em descrições de pacote"

msgid "Descriptions can include Texinfo markup, which is useful to introduce ornaments such as @code{@@code} or @code{@@dfn}, bullet lists, or hyperlinks (@pxref{Overview,,, texinfo, GNU Texinfo}).  However you should be careful when using some characters for example @samp{@@} and curly braces which are the basic special characters in Texinfo (@pxref{Special Characters,,, texinfo, GNU Texinfo}).  User interfaces such as @command{guix show} take care of rendering it appropriately."
msgstr "As descrições podem incluir marcação Texinfo, que é útil para introduzir ornamentos como @code{@@code} ou @code{@@dfn}, listas de marcadores ou hiperlinks (@pxref{Overview,,, texinfo, GNU Texinfo}). No entanto, você deve ter cuidado ao usar alguns caracteres, por exemplo @samp{@@} e chaves, que são os caracteres especiais básicos em Texinfo (@pxref{Special Characters,,, texinfo, GNU Texinfo}). Interfaces de usuário como @command{guix show} cuidam de renderizá-lo apropriadamente."

msgid "Synopses and descriptions are translated by volunteers @uref{https://translate.codeberg.org/projects/guix/packages, at Weblate} so that as many users as possible can read them in their native language.  User interfaces search them and display them in the language specified by the current locale."
msgstr "Sinopses e descrições são traduzidas por voluntários @uref{https://translate.codeberg.org/projects/guix/packages, no Weblate} para que o maior número possível de usuários possam lê-las em seu idioma nativo. As interfaces de usuário os pesquisam e os exibem no idioma especificado pelo código do idioma atual."

msgid "To allow @command{xgettext} to extract them as translatable strings, synopses and descriptions @emph{must be literal strings}.  This means that you cannot use @code{string-append} or @code{format} to construct these strings:"
msgstr "Para permitir que @command{xgettext} extrai-as com strings traduzíveis, as sinopses e descrições @emph{devem ser strings literais}. Isso significa que você não pode usar @code{string-append} ou @code{format} para construir essas strings:"

msgid ""
"(package\n"
"  ;; @dots{}\n"
"  (synopsis \"This is translatable\")\n"
"  (description (string-append \"This is \" \"*not*\" \" translatable.\")))\n"
msgstr ""
"(package\n"
"  ;; @dots{}\n"
"  (synopsis \"Isso é traduzível\")\n"
"  (description (string-append \"Isso \" \"*não*\" \" é traduzível.\")))\n"

msgid "Translation is a lot of work so, as a packager, please pay even more attention to your synopses and descriptions as every change may entail additional work for translators.  In order to help them, it is possible to make recommendations or instructions visible to them by inserting special comments like this (@pxref{xgettext Invocation,,, gettext, GNU Gettext}):"
msgstr "Tradução é muito trabalhoso, então, como empacotador, por favor, tenha ainda mais atenção às suas sinopses e descrições, pois cada alteração pode implicar em trabalho adicional para tradutores. Para ajudá-loas, é possível tornar recomendações ou instruções visíveis inserindo comentários especiais como esse (@pxref{xgettext Invocation,,, gettext, GNU Gettext}):"

msgid ""
";; TRANSLATORS: \"X11 resize-and-rotate\" should not be translated.\n"
"(description \"ARandR is designed to provide a simple visual front end\n"
"for the X11 resize-and-rotate (RandR) extension. @dots{}\")\n"
msgstr ""
";; TRANSLATORS: \"X11 resize-and-rotate\" should not be translated.\n"
"(description \"ARandR is designed to provide a simple visual front end\n"
"for the X11 resize-and-rotate (RandR) extension. @dots{}\")\n"

msgid "snippets, when to use"
msgstr "snippets, quando usar"

msgid "The boundary between using an origin snippet versus a build phase to modify the sources of a package can be elusive.  Origin snippets are typically used to remove unwanted files such as bundled libraries, nonfree sources, or to apply simple substitutions.  The source derived from an origin should produce a source that can be used to build the package on any system that the upstream package supports (i.e., act as the corresponding source).  In particular, origin snippets must not embed store items in the sources; such patching should rather be done using build phases.  Refer to the @code{origin} record documentation for more information (@pxref{origin Reference})."
msgstr "A fronteira entre usar um snippet de origem e uma fase de construção para modificar as fontes de um pacote pode ser ilusória. Os snippets de origem são normalmente usados para remover arquivos indesejados, como bibliotecas agrupadas, fontes não livres ou para aplicar substituições simples. A fonte derivada de uma origem deve produzir uma fonte que possa ser usada para construir o pacote em qualquer sistema que o pacote suporte (ou seja, atuar como a fonte correspondente). Em particular, os snippets de origem não devem incorporar itens do armazém nas fontes; tal correção deve ser feita usando fases de construção. Consulte a documentação do registro @code{origin} para obter mais informações (@pxref{origin Reference})."

msgid "While there cannot be circular dependencies between packages, Guile's lax module loading mechanism allows circular dependencies between Guile modules, which doesn't cause problems as long as the following conditions are followed for two modules part of a dependency cycle:"
msgstr "Embora não possa haver dependências circulares entre pacotes, o mecanismo frouxo de carregamento de módulos do Guile permite dependências circulares entre módulos do Guile, o que não causa problemas, desde que as seguintes condições sejam seguidas para dois módulos que fazem parte de um ciclo de dependência:"

msgid "rules to cope with circular module dependencies"
msgstr "regras para lidar com dependências de módulos circulares"

msgid "Macros are not shared between the co-dependent modules"
msgstr "As macros não devem ser compartilhadas entre os módulos co-dependentes"

msgid "Top-level variables are only referenced in delayed (@i{thunked}) package fields: @code{arguments}, @code{native-inputs}, @code{inputs}, @code{propagated-inputs} or @code{replacement}"
msgstr "Variáveis de nível superior são referenciadas apenas em campos de pacote atrasados (@i{thunked}): @code{arguments}, @code{native-inputs}, @code{inputs}, @code{propagated-inputs} ou @code{replacement}"

msgid "Procedures referencing top-level variables from another module are not called at the top level of a module themselves."
msgstr "Procedimentos que fazem referência a variáveis de nível superior de outro módulo não são chamados no nível superior de um módulo."

msgid "Straying away from the above rules may work while there are no dependency cycles between modules, but given such cycles are confusing and difficult to troubleshoot, it is best to follow the rules to avoid introducing problems down the line."
msgstr "Afastar-se das regras acima pode funcionar enquanto não houver ciclos de dependência entre os módulos, mas como tais ciclos são confusos e difíceis de solucionar, é melhor seguir as regras para evitar a introdução de problemas no futuro."

msgid "Here is a common trap to avoid:"
msgstr "Aqui está uma armadilha comum a ser evitada:"

msgid ""
"(define-public avr-binutils\n"
"  (package\n"
"    (inherit (cross-binutils \"avr\"))\n"
"    (name \"avr-binutils\")))\n"
msgstr ""
"(define-public avr-binutils\n"
"  (package\n"
"    (inherit (cross-binutils \"avr\"))\n"
"    (name \"avr-binutils\")))\n"

msgid "In the above example, the @code{avr-binutils} package was defined in the module @code{(gnu packages avr)}, and the @code{cross-binutils} procedure in @code{(gnu packages cross-base)}.  Because the @code{inherit} field is not delayed (thunked), it is evaluated at the top level at load time, which is problematic in the presence of module dependency cycles.  This could be resolved by turning the package into a procedure instead, like:"
msgstr "No exemplo acima, o pacote @code{avr-binutils} foi definido no módulo @code{(gnu packages avr)}, e o procedimento @code{cross-binutils} em @code{(gnu packages cross-base)}. Como o campo @code{inherit} não é atrasado (thunked), ele é avaliado no nível superior no momento do carregamento, o que é problemático na presença de ciclos de dependência do módulo. Isso pode ser resolvido transformando o pacote em um procedimento, como:"

msgid ""
"(define (make-avr-binutils)\n"
"  (package\n"
"    (inherit (cross-binutils \"avr\"))\n"
"    (name \"avr-binutils\")))\n"
msgstr ""
"(define (make-avr-binutils)\n"
"  (package\n"
"    (inherit (cross-binutils \"avr\"))\n"
"    (name \"avr-binutils\")))\n"

msgid "Care would need to be taken to ensure the above procedure is only ever used in a package delayed fields or within another procedure also not called at the top level."
msgstr "Seria necessário tomar cuidado para garantir que o procedimento acima só seja usado em campos atrasados de pacote ou dentro de outro procedimento também não chamado no nível superior."

msgid "packaging, maintenance"
msgstr "empacotamento, manutenção"

msgid "Sometimes you may need to update a monotonic collection of grouped packages, in a particular module---e.g., @code{(gnu packages astronomy)}.  Doing so requires refreshing package versions, creating commits following guidelines and testing them.  Let's say there are 200+ packages with fresh versions, you may deal with this task by applying the following technique."
msgstr "Às vezes, em um módulo específico, você pode precisar atualizar uma coleção monótona de pacotes --- por exemplo, @code{(gnu packages astronomy)}. Isso requer a atualização das versões dos pacotes, a criação de commits seguindo as diretrizes e testando-os. Digamos que haja mais de 200 pacotes com versões novas; você pode realizar essa tarefa aplicando a seguinte técnica."

msgid "Enter a development shell in your local Guix checkout, assuming you already ran @code{bootstrap} and @code{configure}:"
msgstr "Crie um shell de desenvolvimento no seu checkout local de Guix, supondo que você já tenha executado @code{bootstrap} e @code{configure}:"

msgid ""
"~$ guix shell --development guix\n"
"[env: /gnu/store/@dots{}-profile]\n"
"> ./pre-inst-env guix refresh --select=module:astronomy --update\n"
"> ./pre-inst-env etc/committer.scm\n"
msgstr ""
"~$ guix shell --development guix\n"
"[env: /gnu/store/@dots{}-profile]\n"
"> ./pre-inst-env guix refresh --select=module:astronomy --update\n"
"> ./pre-inst-env etc/committer.scm\n"

msgid "The first command updates all packages in @code{(gnu packages astronomy)} to the latest versions and writes changes back to the file.  The second invokes @code{etc/committer.scm} script, a helper script for larger scale updates; it identifies each package diff and creates corresponding commits with the correct style."
msgstr "O primeiro comando atualiza todos os pacotes em @code{(gnu packages astronomy)} para as versões mais recentes e grava as alterações em arquivo. O segundo invoca o script @code{etc/committer.scm}, um script auxiliar para atualizações em larga escala; ele identifica cada diff de pacote e cria os commits correspondentes com o estilo correto."

msgid "If your machine is powerful enough, you may check that the whole collection has no regressions and can still be built successfully:"
msgstr "Se sua máquina for potente o suficiente, você pode verificar se toda a coleção não tem regressões e ainda pode ser compilada com sucesso:"

msgid ""
"[env: /gnu/store/@dots{}-profile]\n"
"> ./pre-inst-env guix build $(./pre-inst-env guix package -A | awk '/astronomy.scm/@{print $1\"@@\"$2@}')\n"
msgstr ""
"[env: /gnu/store/@dots{}-profile]\n"
"> ./pre-inst-env guix build $(./pre-inst-env guix package -A | awk '/astronomy.scm/@{print $1\"@@\"$2@}')\n"

msgid "emacs, packaging"
msgstr "emacs, empacotando"

msgid "elisp, packaging"
msgstr "elisp, empacotando"

msgid "Emacs packages should preferably use the Emacs build system (@pxref{emacs-build-system}), for uniformity and the benefits provided by its build phases, such as the auto-generation of the autoloads file and the byte compilation of the sources.  Because there is no standardized way to run a test suite for Emacs packages, tests are disabled by default.  When a test suite is available, it should be enabled by setting the @code{#:tests?} argument to @code{#true}.  By default, the command to run the test is @command{make check}, but any command can be specified via the @code{#:test-command} argument.  The @code{#:test-command} argument expects a list containing a command and its arguments, to be invoked during the @code{check} phase."
msgstr "Os pacotes Emacs devem preferencialmente usar o sistema de compilação Emacs (@pxref{emacs-build-system}), para uniformidade e os benefícios proporcionados por suas fases de compilação, como a geração automática do arquivo autoloads e a compilação de bytes das fontes. Como não existe uma maneira padronizada de executar um conjunto de testes para pacotes Emacs, os testes são desabilitados por padrão. Quando um conjunto de testes estiver disponível, ele deverá ser habilitado definindo o argumento @code{#:tests?} como @code{#true}. Por padrão, o comando para executar o teste é @command{make check}, mas qualquer comando pode ser especificado através do argumento @code{#:test-command}. O argumento @code{#:test-command} espera que uma lista contendo um comando e seus argumentos seja invocada durante a fase @code{check}."

msgid "The Elisp dependencies of Emacs packages are typically provided as @code{propagated-inputs} when required at run time.  As for other packages, build or test dependencies should be specified as @code{native-inputs}."
msgstr "As dependências Elisp dos pacotes Emacs são normalmente fornecidas como @code{propagated-inputs} quando necessário em tempo de execução. Quanto a outros pacotes, as dependências de construção ou teste devem ser especificadas como @code{native-inputs}."

msgid "Emacs packages sometimes depend on resources directories that should be installed along the Elisp files.  The @code{#:include} argument can be used for that purpose, by specifying a list of regexps to match.  The best practice when using the @code{#:include} argument is to extend rather than override its default value (accessible via the @code{%default-include} variable).  As an example, a yasnippet extension package typically include a @file{snippets} directory, which could be copied to the installation directory using:"
msgstr "Pacotes Emacs às vezes dependem de diretórios de recursos que devem ser instalados junto com os arquivos Elisp. O argumento @code{#:include} pode ser usado para esse propósito, especificando uma lista de regexps para corresponder. A melhor prática ao usar o argumento @code{#:include} é estender em vez de substituir seu valor padrão (acessível por meio da variável @code{%default-include}). Como exemplo, um pacote de extensão yasnippet normalmente inclui um diretório @file{snippets}, que pode ser copiado para o diretório de instalação usando:"

msgid "#:include (cons \"^snippets/\" %default-include)\n"
msgstr "#:include (cons \"^snippets/\" %default-include)\n"

msgid "When encountering problems, it is wise to check for the presence of the @code{Package-Requires} extension header in the package main source file, and whether any dependencies and their versions listed therein are satisfied."
msgstr "Ao encontrar problemas, é aconselhável verificar a presença do cabeçalho de extensão @code{Package-Requires} no arquivo de origem principal do pacote e se quaisquer dependências e suas versões listadas nele foram atendidas."

msgid "python"
msgstr "python"

msgid "Specifying Dependencies"
msgstr "Especificando dependências"

msgid "inputs, for Python packages"
msgstr "entradas, para pacotes Python"

msgid "Dependency information for Python packages is usually available in the package source tree, with varying degrees of accuracy: in the @file{pyproject.toml} file, the @file{setup.py} file, in @file{requirements.txt}, or in @file{tox.ini} (the latter mostly for test dependencies)."
msgstr "Informações de dependências para pacotes Python estão geralmente disponíveis na árvore de fonte do pacote, com variados graus de precisão nos arquivos: @file{setup.py}, @file{requirements.txt} ou @file{tox.ini} (este último principalmente para testes de dependência)."

msgid "Python dependencies required at run time go into @code{propagated-inputs}.  They are typically defined with the @code{install_requires} keyword in @file{setup.py}, or in the @file{requirements.txt} file."
msgstr "Dependências de Python necessárias em tempo de execução vão em @code{propagated-inputs}. Elas geralmente são definidas com a palavra-chave @code{install_requires} em @file{setup.py} ou no arquivo @file{requirements.txt}."

msgid "Examples are the @code{pytest}, @code{mock}, and @code{stestr} test frameworks.  Of course if any of these packages is also required at run-time, it needs to go to @code{propagated-inputs}."
msgstr "Exemplos são os frameworks de teste @code{pytest}, @code{mock} e @code{stestr}. É claro, se qualquer um desses pacotes também for necessário em tempo de compilação, ele precisa ir para @code{propagated-inputs}."

msgid "Anything that does not fall in the previous categories goes to @code{inputs}, for example programs or C libraries required for building Python packages containing C extensions."
msgstr "Qualquer coisa que não encaixar nas categorias anteriores vai para @code{inputs}. Por exemplo, programas ou bibliotecas C necessárias para compilar pacotes Python contendo extensões C."

msgid "If a Python package has optional dependencies (@code{extras_require}), it is up to you to decide whether to add them or not, based on their usefulness/overhead ratio (@pxref{Submitting Patches, @command{guix size}})."
msgstr "Se um pacote Python tem dependências opcionais (@code{extras_require}), fica a seu critério adicioná-las ou não, com base na sua proporção de utilidade/sobrecarga (@pxref{Submitting Patches, @command{guix size}})."

msgid "perl"
msgstr "perl"

msgid "Perl programs standing for themselves are named as any other package, using the lowercase upstream name.  For Perl packages containing a single class, we use the lowercase class name, replace all occurrences of @code{::} by dashes and prepend the prefix @code{perl-}.  So the class @code{XML::Parser} becomes @code{perl-xml-parser}.  Modules containing several classes keep their lowercase upstream name and are also prepended by @code{perl-}.  Such modules tend to have the word @code{perl} somewhere in their name, which gets dropped in favor of the prefix.  For instance, @code{libwww-perl} becomes @code{perl-libwww}."
msgstr "Os programas Perl próprios são nomeados como qualquer outro pacote, usando o nome upstream em letras minúsculas. Para pacotes Perl que contêm uma única classe, usamos o nome da classe em letras minúsculas, substituímos todas as ocorrências de @code{::} por traços e precede o prefixo @code{perl-}. Portanto, a classe @code{XML::Parser} se torna @code{perl-xml-parser}. Módulos contendo várias classes mantêm seu nome upstream em minúsculas e também são precedidos por @code{perl-}. Esses módulos tendem a ter a palavra @code{perl} em algum lugar do nome, que é descartada em favor do prefixo. Por exemplo, @code{libwww-perl} se torna @code{perl-libwww}."

msgid "java"
msgstr "java"

msgid "Java programs standing for themselves are named as any other package, using the lowercase upstream name."
msgstr "Os programas Java próprios são nomeados como qualquer outro pacote, usando o nome do upstream em letras minúsculas."

msgid "To avoid confusion and naming clashes with other programming languages, it is desirable that the name of a package for a Java package is prefixed with @code{java-}.  If a project already contains the word @code{java}, we drop this; for instance, the package @code{ngsjava} is packaged under the name @code{java-ngs}."
msgstr "Para evitar confusão e conflitos de nomes com outras linguagens de programação, é desejável que o nome de um pacote para um pacote Java seja prefixado com @code{java-}. Se um projeto já contém a palavra @code{java}, descartamos isso; por exemplo, o pacote @code{ngsjava} é empacotado com o nome @code{java-ngs}."

msgid "For Java packages containing a single class or a small class hierarchy, we use the lowercase class name, replace all occurrences of @code{.} by dashes and prepend the prefix @code{java-}.  So the class @code{apache.commons.cli} becomes package @code{java-apache-commons-cli}."
msgstr "Para pacotes Java que contêm uma única classe ou uma pequena hierarquia de classes, usamos o nome da classe em letras minúsculas, substitua todas as ocorrências de @code{.} por traços e acrescente o prefixo @code{java-}. Assim, a classe @code{apache.commons.cli} se torna o pacote @code{java-apache-commons-cli}."

msgid "rust"
msgstr "rust"

msgid "Rust applications (binary crates) and libraries (library crates) are packaged separately.  We put our main efforts into applications and only package libraries as sources, utilizing automation with a manual focus on unbundling vendored dependencies."
msgstr "Aplicações em Rust (crates binários) e bibliotecas (crates de biblioteca) são empacotadas separadamente. Concentramos nossos esforços nas aplicações e empacotamos as bibliotecas apenas como código-fonte, utilizando automação com foco manual na separação das dependências que venham empacotadas na biblioteca (vendored dependencies)."

msgid "Rust applications are treated like any other package and named using the lowercase upstream name.  When using the Cargo build system (@pxref{Build Systems, @code{cargo-build-system}}), Rust applications should have the @code{#:install-source?} parameter set to @code{#f}, as this parameter only makes sense for libraries.  When the package source is a Cargo workspace, @code{#:cargo-install-paths} must be set to enable relevant support."
msgstr "Aplicações Rust são tratadas como qualquer outro pacote e nomeadas usando o nome original em minúsculas.  Ao usar o sistema de compilação Cargo (@pxref{Sistemas de compilação, @code{cargo-build-system}}), o parâmetro @code{#:install-source?} deve ser definido como @code{#f} para aplicações Rust, pois esse parâmetro só faz sentido para bibliotecas.  Quando a origem do pacote é um espaço de trabalho Cargo, o parâmetro @code{#:cargo-install-paths} deve ser definido para habilitar o suporte relevante."

msgid "Rust libraries are hidden from the user interface and managed in two modules:"
msgstr "As bibliotecas Rust ficam ocultas da interface do usuário e são gerenciadas em dois módulos:"

msgid "(gnu packages rust-crates)"
msgstr "(gnu packages rust-crates)"

msgid "Source definitions imported from Rust packages' @file{Cargo.lock} via the @code{crate} importer (@pxref{Invoking guix import})."
msgstr "Definições de código fonte importadas a partir do arquivo @file{Cargo.lock} do pacote Rust através do importador @code{crate} (@pxref{Invoking guix import})."

msgid "Imported definitions must be checked and have vendored dependencies unbundled before being contributed to Guix."
msgstr "Definições importadas devem ser verificadas e as dependências embutidas devem ser removidas antes de serem contribuídas para o Guix."

msgid "(gnu packages rust-sources)"
msgstr "(gnu packages rust-sources)"

msgid "More complex definitions that need to be full packages.  This includes Rust libraries requiring external inputs to unbundle and Cargo workspaces."
msgstr "Definições mais complexas que precisam ser pacotes completos.  Isso inclui bibliotecas Rust que requerem entradas externas para serem descompactadas e espaços de trabalho do Cargo."

msgid "These libraries should have the @code{#:skip-build?} parameter set to @code{#t}.  For Cargo workspaces, @code{#:cargo-package-crates} must be set."
msgstr "Essas bibliotecas devem ter o parâmetro @code{#:skip-build?} definido como @code{#t}.  Para espaços de trabalho Cargo, o parâmetro @code{#:cargo-package-crates} deve ser definido."

msgid "Since they are added manually, they follow the usual naming convention for Guix packages (@pxref{Package Naming}), with a @code{rust-} prefix."
msgstr "Como são adicionados manualmente, eles seguem a convenção de nomenclatura usual para pacotes Guix (@pxref{Nomeando um pacote}), com o prefixo @code{rust-}."

msgid "In the Rust community it is common for multiple incompatible versions of a package to be used at any given time, so all libraries should have a versioned suffix.  The versioned suffix is the left-most non-zero digit (and any leading zeros, of course).  This follows the ``caret'' version scheme intended by Cargo.  Examples@: @code{rust-clap-2}, @code{rust-rand-0.6}."
msgstr "No comunidade Rust é comum que várias versões incompatíveis de um pacote sejam usadas a qualquer momento, então todas as bibliotecas devem ter um sufixo versionado. O sufixo versionado é o dígito diferente de zero mais à esquerda (e quaisquer zeros à esquerda, é claro). Isso segue o esquema de versão ``caret'' pretendido pelo Cargo. Exemplos@: @code{rust-clap-2}, @code{rust-rand-0.6}."

msgid "In practice we often package development snapshots of Rust libraries and can't simply identify them by version.  In this case, the complete version information can be turned into a version string via @code{git-version}, for example @code{rust-pipewire-0.8.0.fd3d8f7} and @code{rust-pubgrub-0.3.0.b70cf70}."
msgstr "Na prática, muitas vezes empacotamos snapshots de desenvolvimento de bibliotecas Rust e não podemos simplesmente identificá-las pela versão. Nesse caso, as informações completas da versão podem ser transformadas em uma string de versão por meio de @code{git-version}, por exemplo, @code{rust-pipewire-0.8.0.fd3d8f7} e @code{rust-pubgrub-0.3.0.b70cf70}."

msgid "To avoid merge conflicts with changes from multiple branches, these two modules are maintained by the Rust team (@pxref{Teams})."
msgstr "Para evitar conflitos de merge com mudanças de várias branches, esses dois módulos são mantidos pela equipe de Rust (@pxref{Teams})."

msgid "Rust libraries are not referenced directly.  @code{(guix build-sytem cargo)} provides a @code{cargo-inputs} procedure to lookup input lists generated by the lockfile importer."
msgstr "Bibliotecas Rust não são referenciadas diretamente.  @code{(guix build-system cargo)} provê um procedimento @code{cargo-inputs} para pesquisar listas de entrada geradas pelo importador do lockfile."

msgid "define-cargo-inputs"
msgstr "define-cargo-inputs"

msgid "Lookup Cargo inputs for @var{name} in @var{module}, return an empty list if unavailable."
msgstr "Pesquisa entradas de Cargo para @var{name} em @var{module}, retorna uma lista vazia se indisponível."

msgid "@var{name} must be consistent with the one used in lockfile importer invocation, usually matching the variable name of the package:"
msgstr "@var{name} deve ser consistente com o nome usado na invocação do importador do lockfile, geralmente se assimilando com o nome do pacote:"

msgid "@var{module} must export a public interface @code{lookup-cargo-inputs}, a template is available in the @file{etc/teams/rust} directory of Guix source tree."
msgstr "@var{module} deve exportar uma interface pública @code{lookup-cargo-inputs}, um template está disponível no diretório @file{etc/teams/rust} da source tree do Guix."

msgid "Elm"
msgstr "Elm"

msgid "Elm applications can be named like other software: their names need not mention Elm."
msgstr "Os aplicativos Elm podem ser nomeados como outros softwares: seus nomes não precisam mencionar Elm."

msgid "Packages in the Elm sense (see @code{elm-build-system} under @ref{Build Systems}) are required use names of the format @var{author}@code{/}@var{project}, where both the @var{author} and the @var{project} may contain hyphens internally, and the @var{author} sometimes contains uppercase letters."
msgstr "Pacotes no sentido Elm (veja @code{elm-build-system} em @ref{Build Systems}) devem usar nomes no formato @var{author}@code{/}@var{project}, onde tanto @var{author} quanto @var{project} podem conter hifens internamente, e @var{author} às vezes contém letras maiúsculas."

msgid "To form the Guix package name from the upstream name, we follow a convention similar to Python packages (@pxref{Python Modules}), adding an @code{elm-} prefix unless the name would already begin with @code{elm-}."
msgstr "Para formar o nome do pacote Guix a partir do nome upstream, seguimos uma convenção semelhante aos pacotes Python (@pxref{Python Modules}), adicionando um prefixo @code{elm-}, a menos que o nome já comece com @code{elm-}."

msgid "In many cases we can reconstruct an Elm package's upstream name heuristically, but, since conversion to a Guix-style name involves a loss of information, this is not always possible.  Care should be taken to add the @code{'upstream-name} property when necessary so that @samp{guix import elm} will work correctly (@pxref{Invoking guix import}). The most notable scenarios when explicitly specifying the upstream name is necessary are:"
msgstr "Em muitos casos, podemos reconstruir o nome upstream de um pacote Elm heuristicamente, mas, como a conversão para um nome no estilo Guix envolve perda de informações, isso nem sempre é possível. Deve-se tomar cuidado para adicionar a propriedade @code{'upstream-name} quando necessário para que @samp{guix import elm} funcione corretamente (@pxref{Invoking guix import}). Os cenários mais notáveis quando especificar explicitamente o nome upstream é necessário são:"

msgid "When the @var{author} is @code{elm} and the @var{project} contains one or more hyphens, as with @code{elm/virtual-dom}; and"
msgstr "Quando @var{author} é @code{elm} e @var{project} contém um ou mais hifens, como em @code{elm/virtual-dom}; e"

msgid "When the @var{author} contains hyphens or uppercase letters, as with @code{Elm-Canvas/raster-shapes}---unless the @var{author} is @code{elm-explorations}, which is handled as a special case, so packages like @code{elm-explorations/markdown} do @emph{not} need to use the @code{'upstream-name} property."
msgstr "Quando @var{author} contém hifens ou letras maiúsculas, como em @code{Elm-Canvas/raster-shapes}---a menos que @var{author} seja @code{elm-explorations}, que é tratado como um caso especial, então pacotes como @code{elm-explorations/markdown} @emph{não} precisam usar a propriedade @code{'upstream-name}."

msgid "The module @code{(guix build-system elm)} provides the following utilities for working with names and related conventions:"
msgstr "O módulo @code{(guix build-system elm)} fornece os seguintes utilitários para trabalhar com nomes e convenções relacionadas:"

msgid "{Procedure} elm-package-origin @var{elm-name} @var{version} @"
msgstr "{Procedimento} elm-package-origin @var{nome-elm} @var{versão} @"

msgid "@var{hash} Returns a Git origin using the repository naming and tagging regime required for a published Elm package with the upstream name @var{elm-name} at version @var{version} with sha256 checksum @var{hash}."
msgstr "@var{hash} Retorna uma origem Git usando o regime de nomenclatura e marcação de repositório necessário para um pacote Elm publicado com o nome upstream @var{nome-elm} na versão @var{versão} com soma de verificação sha256 @var{hash}."

msgid "For example:"
msgstr "Por exemplo:"

msgid ""
"(package\n"
"  (name \"elm-html\")\n"
"  (version \"1.0.0\")\n"
"  (source\n"
"   (elm-package-origin\n"
"    \"elm/html\"\n"
"    version\n"
"    (base32 \"15k1679ja57vvlpinpv06znmrxy09lbhzfkzdc89i01qa8c4gb4a\")))\n"
"  ...)\n"
msgstr ""
"(package\n"
"  (name \"elm-html\")\n"
"  (version \"1.0.0\")\n"
"  (source\n"
"   (elm-package-origin\n"
"    \"elm/html\"\n"
"    version\n"
"    (base32 \"15k1679ja57vvlpinpv06znmrxy09lbhzfkzdc89i01qa8c4gb4a\")))\n"
"  ...)\n"

msgid "{Procedure} elm->package-name @var{elm-name}"
msgstr "{Procedimento} elm->package-name @var{nome-elm}"

msgid "Returns the Guix-style package name for an Elm package with upstream name @var{elm-name}."
msgstr "Retorna o nome do pacote no estilo Guix para um pacote Elm com nome upstream @var{nome-elm}."

msgid "Note that there is more than one possible @var{elm-name} for which @code{elm->package-name} will produce a given result."
msgstr "Observe que há mais de um @var{nome-elm} possível para o qual @code{elm->package-name} produzirá um determinado resultado."

msgid "{Procedure} guix-package->elm-name @var{package}"
msgstr "{Procedimento} guix-package->elm-name @var{pacote}"

msgid "Given an Elm @var{package}, returns the possibly-inferred upstream name, or @code{#f} the upstream name is not specified via the @code{'upstream-name} property and can not be inferred by @code{infer-elm-package-name}."
msgstr "Dado um Elm @var{pacote}, retorna o nome upstream possivelmente inferido, ou @code{#f} o nome upstream não é especificado por meio da propriedade @code{'upstream-name} e não pode ser inferido por @code{infer-elm-package-name}."

msgid "{Procedure} infer-elm-package-name @var{guix-name}"
msgstr "{Procedimento} infer-elm-package-name @var{guix-name}"

msgid "Given the @var{guix-name} of an Elm package, returns the inferred upstream name, or @code{#f} if the upstream name can't be inferred.  If the result is not @code{#f}, supplying it to @code{elm->package-name} would produce @var{guix-name}."
msgstr "Dado o @var{guix-name} de um pacote Elm, retorna o nome upstream inferido, ou @code{#f} se o nome upstream não puder ser inferido. Se o resultado não for @code{#f}, fornecê-lo a @code{elm->package-name} produziria @var{guix-name}."

msgid "fonts"
msgstr "fontes"

msgid "For fonts that are in general not installed by a user for typesetting purposes, or that are distributed as part of a larger software package, we rely on the general packaging rules for software; for instance, this applies to the fonts delivered as part of the X.Org system or fonts that are part of TeX Live."
msgstr "Para fontes que geralmente não são instaladas por um usuário para fins de digitação ou que são distribuídas como parte de um pacote de software maior, contamos com as regras gerais de empacotamento de software; por exemplo, isso se aplica às fontes entregues como parte do sistema X.Org ou às fontes que fazem parte do TeX Live."

msgid "To make it easier for a user to search for fonts, names for other packages containing only fonts are constructed as follows, independently of the upstream package name."
msgstr "Para facilitar a busca de fontes por um usuário, os nomes de outros pacotes contendo apenas fontes são compilados da seguinte maneira, independentemente do nome do pacote upstream."

msgid "The name of a package containing only one font family starts with @code{font-}; it is followed by the foundry name and a dash @code{-} if the foundry is known, and the font family name, in which spaces are replaced by dashes (and as usual, all upper case letters are transformed to lower case).  For example, the Gentium font family by SIL is packaged under the name @code{font-sil-gentium}."
msgstr "O nome de um pacote que contém apenas uma família de fontes começa com @code{font-}; é seguido pelo nome da fundição e um traço @code{-} se a fundição for conhecida e o nome da família da fonte, em que os espaços são substituídos por hífenes (e, como sempre, todas as letras maiúsculas são transformadas em minúsculas). Por exemplo, a família de fontes Gentium da SIL é empacotada com o nome @code{font-sil-gentium}."

msgid "For a package containing several font families, the name of the collection is used in the place of the font family name.  For instance, the Liberation fonts consist of three families, Liberation Sans, Liberation Serif and Liberation Mono.  These could be packaged separately under the names @code{font-liberation-sans} and so on; but as they are distributed together under a common name, we prefer to package them together as @code{font-liberation}."
msgstr "Para um pacote que contém várias famílias de fontes, o nome da coleção é usado no lugar do nome da família de fontes. Por exemplo, as fontes Liberation consistem em três famílias, Liberation Sans, Liberation Serif e Liberation Mono. Eles podem ser empacotados separadamente com os nomes @code{font-liberation-sans} e assim por diante; mas como eles são distribuídos juntos com um nome comum, preferimos agrupá-los como @code{font-liberation}."

msgid "In the case where several formats of the same font family or font collection are packaged separately, a short form of the format, prepended by a dash, is added to the package name.  We use @code{-ttf} for TrueType fonts, @code{-otf} for OpenType fonts and @code{-type1} for PostScript Type 1 fonts."
msgstr "No caso de vários formatos da mesma família ou coleção de fontes serem empacotados separadamente, um formato abreviado do formato, precedido por um traço, é adicionado ao nome do pacote. Usamos @code{-ttf} para fontes TrueType, @code{-otf} para fontes OpenType e @code{-type1} para fontes PostScript Type 1."

msgid "In general our code follows the GNU Coding Standards (@pxref{Top,,, standards, GNU Coding Standards}).  However, they do not say much about Scheme, so here are some additional rules."
msgstr "Em geral, nosso código segue os Padrões de Codificação GNU (@pxref{Top ,,, standards, GNU Coding Standards}). No entanto, eles não dizem muito sobre Scheme, então aqui estão algumas regras adicionais."

msgid "Programming Paradigm"
msgstr "Paradigma de programação"

msgid "How to compose your elements."
msgstr "Como compor seus elementos."

msgid "Modules"
msgstr "Módulos"

msgid "Where to store your code?"
msgstr "Onde armazenar seu código?"

msgid "Data Types and Pattern Matching"
msgstr "Tipos de dados e correspondência de padrão"

msgid "Implementing data structures."
msgstr "Implementação de estruturas de dados."

msgid "Formatting Code"
msgstr "Formatação de código"

msgid "Writing conventions."
msgstr "Convenções de escrita."

msgid "Scheme code in Guix is written in a purely functional style.  One exception is code that involves input/output, and procedures that implement low-level concepts, such as the @code{memoize} procedure."
msgstr "O código Scheme no Guix é escrito em um estilo puramente funcional. Uma exceção é o código que envolve entrada/saída e procedimentos que implementam conceitos de baixo nível, como o procedimento @code{memoize}."

msgid "build-side modules"
msgstr "módulos da banda de compilação"

msgid "host-side modules"
msgstr "módulos do lado do host"

msgid "Guile modules that are meant to be used on the builder side must live in the @code{(guix build @dots{})} name space.  They must not refer to other Guix or GNU modules.  However, it is OK for a ``host-side'' module to use a build-side module.  As an example, the @code{(guix search-paths)} module should not be imported and used by a package since it isn't meant to be used as a ``build-side'' module.  It would also couple the module with the package's dependency graph, which is undesirable."
msgstr "Os módulos do Guile que devem ser usados no lado do compilador devem residir no espaço de nomes @code{(guix build @dots{})}. Eles não devem fazer referência a outros módulos Guix ou GNU. No entanto, é aceitável que um módulo no lado do ``hospedeiro'' use um módulo na banda do compilador. Como um exemplo, o módulo @code{(guix search-paths)} não deveria ser importado e usado por um pacote desde que o mesmo não é feito para ser usado como módulo da ``banda de compilação''.  Isso também acoplaria o módulo ao grafo de pacotes de dependência, o que não é desejado."

msgid "Modules that deal with the broader GNU system should be in the @code{(gnu @dots{})} name space rather than @code{(guix @dots{})}."
msgstr "Módulos que lidam com o sistema GNU mais amplo devem estar no espaço de nome @code{(gnu @dots{})} em vez de @code{(guix @dots{})}."

msgid "The tendency in classical Lisp is to use lists to represent everything, and then to browse them ``by hand'' using @code{car}, @code{cdr}, @code{cadr}, and co.  There are several problems with that style, notably the fact that it is hard to read, error-prone, and a hindrance to proper type error reports."
msgstr "A tendência no Lisp clássico é usar listas para representar tudo e, em seguida, pesquisá-las ``à mão'' usando @code{car}, @code{cdr}, @code{cadr} e co. Existem vários problemas com esse estilo, notadamente o fato de que é difícil de ler, propenso a erros e um obstáculo para os relatórios de erros de tipos adequados."

msgid "define-record-type*"
msgstr "define-record-type*"

msgid "match-record"
msgstr "match-record"

msgid "pattern matching"
msgstr "correspondência de padrão"

msgid "Guix code should define appropriate data types (for instance, using @code{define-record-type*}) rather than abuse lists.  In addition, it should use pattern matching, via Guile’s @code{(ice-9 match)} module, especially when matching lists (@pxref{Pattern Matching,,, guile, GNU Guile Reference Manual}); pattern matching for records is better done using @code{match-record} from @code{(guix records)}, which, unlike @code{match}, verifies field names at macro-expansion time."
msgstr "O código Guix deve definir tipos de dados apropriados (por exemplo, usando @code{define-record-type*}) em vez de listas de abuso. Além disso, ele deve usar correspondência de padrões, por meio do módulo @code{(ice-9 match)} do Guile, especialmente ao corresponder listas (@pxref{Pattern Matching,,, guile, Manual de Referência do GNU Guile}); a correspondência de padrões para registros é melhor feita usando @code{match-record} do @code{(guix records)}, que, diferentemente do @code{match}, verifica nomes de campos no momento da macroexpansão."

msgid "When defining a new record type, keep the @dfn{record type descriptor} (RTD) private (@pxref{Records,,, guile, GNU Guile Reference Manual}, for more on records and RTDs).  As an example, the @code{(guix packages)} module defines @code{<package>} as the RTD for package records but it does not export it; instead, it exports a type predicate, a constructor, and field accessors.  Exporting RTDs would make it harder to change the application binary interface (because code in other modules might be matching fields by position) and would make it trivial for users to forge records of that type, bypassing any checks we may have in the official constructor (such as ``field sanitizers'')."
msgstr "Ao definir um novo tipo de registro, mantenha o @dfn{record type descriptor} (RTD) privado (@pxref{Records,,, guile, Manual de Referência do GNU Guile}, para mais informações sobre registros e RTDs). Como exemplo, o módulo @code{(guix packages)} define @code{<package>} como o RTD para registros de pacote, mas não o exporta; em vez disso, ele exporta um predicado de tipo, um construtor e acessadores de campo. Exportar RTDs tornaria mais difícil alterar a interface binária do aplicativo (porque o código em outros módulos pode estar correspondendo campos por posição) e tornaria trivial para os usuários falsificar registros desse tipo, ignorando quaisquer verificações que possamos ter no construtor oficial (como ``sanitizadores de campo'')."

msgid "formatting code"
msgstr "formatação de código"

msgid "coding style"
msgstr "estilo de codificação"

msgid "When writing Scheme code, we follow common wisdom among Scheme programmers.  In general, we follow the @url{https://mumble.net/~campbell/scheme/style.txt, Riastradh's Lisp Style Rules}.  This document happens to describe the conventions mostly used in Guile’s code too.  It is very thoughtful and well written, so please do read it."
msgstr "Ao escrever código Scheme, seguimos a sabedoria comum entre os programadores Scheme. Em geral, seguimos o @url{https://mumble.net/~campbell/scheme/style.txt, Riastradh's Lisp Style Rules}. Este documento descreve as convenções mais usadas no código de Guile também. Ele é muito bem pensado e bem escrito, então, por favor, leia."

msgid "Some special forms introduced in Guix, such as the @code{substitute*} macro, have special indentation rules.  These are defined in the @file{.dir-locals.el} file, which Emacs automatically uses.  Also note that Emacs-Guix provides @code{guix-devel-mode} mode that indents and highlights Guix code properly (@pxref{Development,,, emacs-guix, The Emacs-Guix Reference Manual})."
msgstr "Alguns formulários especiais introduzidos no Guix, como a macro @code{substitute*}, possuem regras especiais de recuo. Estes são definidos no arquivo @file{.dir-locals.el}, que o Emacs usa automaticamente. Observe também que o Emacs-Guix fornece o modo @code{guix-devel-mode} que recua e destaca o código Guix corretamente (@pxref{Development ,,, emacs-guix, O manual de referência do Emacs-Guix})."

msgid "indentation, of code"
msgstr "recuo, de código"

msgid "formatting, of code"
msgstr "formatação, de código"

msgid "If you do not use Emacs, please make sure your editor knows these rules.  To automatically indent a package definition, you can also run:"
msgstr "Se você não usa o Emacs, por favor, certifique-se que o seu editor conhece estas regras. Para recuar automaticamente uma definição de pacote, você também pode executar:"

msgid "./pre-inst-env guix style @var{package}\n"
msgstr "./pre-inst-env guix style @var{package}\n"

msgid "@xref{Invoking guix style}, for more information."
msgstr "@xref{Invoking guix style}, para mais informações."

msgid "We require all top-level procedures to carry a docstring.  This requirement can be relaxed for simple private procedures in the @code{(guix build @dots{})} name space, though."
msgstr "Nós exigimos que todos os procedimentos de nível superior carreguem uma docstring. Porém, este requisito pode ser relaxado para procedimentos privados simples no espaço de nomes @code{(guix build @dots{})}."

msgid "Procedures should not have more than four positional parameters.  Use keyword parameters for procedures that take more than four parameters."
msgstr "Os procedimentos não devem ter mais de quatro parâmetros posicionais. Use os parâmetros de palavra-chave para procedimentos que levam mais de quatro parâmetros."

msgid "Contributors are encouraged to take a moment to set some Git repository options (@pxref{Configuring Git}) first, which can improve the readability of patches.  Seasoned Guix developers may also want to look at the section on commit access (@pxref{Commit Access})."
msgstr "Os colaboradores são encorajados a reservar um momento para definir algumas opções do repositório Git (@pxref{Configuring Git}) primeiro, o que pode melhorar a legibilidade dos patches. Desenvolvedores Guix experientes também podem querer dar uma olhada na seção sobre acesso de commit (@pxref{Commit Access})."

msgid "Please write commit logs in the ChangeLog format (@pxref{Change Logs,,, standards, GNU Coding Standards}); you can check the commit history for examples."
msgstr "Por favor, escreva os logs de commit no formato de ChangeLog (@pxref{Change Logs ,,, standards, GNU Coding Standards}); você pode verificar o histórico de commit para exemplos."

msgid "You can help make the review process more efficient, and increase the chance that your patch will be reviewed quickly, by describing the context of your patch and the impact you expect it to have.  For example, if your patch is fixing something that is broken, describe the problem and how your patch fixes it.  Tell us how you have tested your patch.  Will users of the code changed by your patch have to adjust their workflow at all? If so, tell us how.  In general, try to imagine what questions a reviewer will ask, and answer those questions in advance."
msgstr "Você pode ajudar a tornar o processo de revisão mais eficiente e aumentar a chance de que seu patch seja revisado rapidamente, descrevendo o contexto do seu patch e o impacto que você espera que ele tenha. Por exemplo, se seu patch estiver corrigindo algo que está quebrado, descreva o problema e como seu patch o corrige. Conte-nos como você testou seu patch. Os usuários do código alterado pelo seu patch terão que ajustar seu fluxo de trabalho? Se sim, conte-nos como. Em geral, tente imaginar quais perguntas um revisor fará e responda a essas perguntas com antecedência."

msgid "Before submitting a patch that adds or modifies a package definition, please run through this check list:"
msgstr "Antes de enviar um patch que adicione ou modifique uma definição de pacote, execute esta lista de verificação:"

msgid "If the authors of the packaged software provide a cryptographic signature for the release tarball, make an effort to verify the authenticity of the archive.  For a detached GPG signature file this would be done with the @code{gpg --verify} command."
msgstr "Se os autores do software empacotado fornecerem uma assinatura criptográfica para o tarball de lançamento, faça um esforço para verificar a autenticidade do arquivo. Para um arquivo de assinatura GPG separado, isso seria feito com o comando @code{gpg --verify}."

msgid "Take some time to provide an adequate synopsis and description for the package.  @xref{Synopses and Descriptions}, for some guidelines."
msgstr "Reserve algum tempo para fornecer uma sinopse e descrição adequadas para o pacote. @xref{Synopses and Descriptions}, para algumas diretrizes."

msgid "Run @command{guix lint @var{package}}, where @var{package} is the name of the new or modified package, and fix any errors it reports (@pxref{Invoking guix lint})."
msgstr "Execute @command{guix lint @var{pacote}}, sendo @var{pacote} o nome do pacote novo ou modificado e corrija quaisquer erros que forem relatados (@pxref{Invoking guix lint})."

msgid "Run @command{guix style @var{package}} to format the new package definition according to the project's conventions (@pxref{Invoking guix style})."
msgstr "Execute @command{guix style @var{pacote}}, para formatar a nova definição de pacote de acordo com as convençôes do projeto (@pxref{Invoking guix style})."

msgid "Make sure the package builds on your platform, using @command{guix build @var{package}}.  Also build at least its direct dependents with @command{guix build --dependents=1 @var{package}} (@pxref{build-dependents, @command{guix build}})."
msgstr "Certifique-se de que o pacote compila em sua plataforma, usando @command{guix build @var{pacote}}. Também compile pelo menos suas depêndencias diretas com @command{guix build --dependents=1 @var{pacote}} (@pxref{build-dependents, @command{guix build}})."

msgid "We recommend you also try building the package on other supported platforms.  As you may not have access to actual hardware platforms, we recommend using the @code{qemu-binfmt-service-type} to emulate them.  In order to enable it, add the @code{virtualization} service module and the following service to the list of services in your @code{operating-system} configuration:"
msgstr "Recomendamos que você também tente compilar o pacote em outras plataformas suportadas. Como você pode não ter acesso às plataformas de hardware reais, recomendamos o uso do @code{qemu-binfmt-service-type} para emulá-las. Para habilitar isso, adicione o módulo de serviço @code{virtualization} e o sequinte serviço à lista de serviços da sua configuração do @code{operating-system}:"

msgid ""
"(service qemu-binfmt-service-type\n"
" (qemu-binfmt-configuration\n"
"   (platforms (lookup-qemu-platforms \"arm\" \"aarch64\"))))\n"
msgstr ""
"(service qemu-binfmt-service-type\n"
" (qemu-binfmt-configuration\n"
"   (platforms (lookup-qemu-platforms \"arm\" \"aarch64\"))))\n"

msgid "Then reconfigure your system."
msgstr "Então, reconfigure seu sistema."

msgid "You can then build packages for different platforms by specifying the @code{--system} option.  For example, to build the \"hello\" package for the armhf or aarch64 architectures, you would run the following commands, respectively:"
msgstr "Você pode criar pacotes para plataformas diferentes especificando a opção @code{--system}. Por exemplo, para compilar o pacote \"hello\" para as arquiteturas armhf ou aarch64, você executaria os seguintes comandos, respectivamente:"

msgid ""
"guix build --system=armhf-linux --rounds=2 hello\n"
"guix build --system=aarch64-linux --rounds=2 hello\n"
msgstr ""
"guix build --system=armhf-linux --rounds=2 hello\n"
"guix build --system=aarch64-linux --rounds=2 hello\n"

msgid "bundling"
msgstr "incorporando"

msgid "Make sure the package does not use bundled copies of software already available as separate packages."
msgstr "Verifique se o pacote não usa cópias de software já disponíveis como pacotes separados."

msgid "Sometimes, packages include copies of the source code of their dependencies as a convenience for users.  However, as a distribution, we want to make sure that such packages end up using the copy we already have in the distribution, if there is one.  This improves resource usage (the dependency is built and stored only once), and allows the distribution to make transverse changes such as applying security updates for a given software package in a single place and have them affect the whole system---something that bundled copies prevent."
msgstr "Às vezes, os pacotes incluem cópias do código-fonte de suas dependências como uma conveniência para os usuários. No entanto, como uma distribuição, queremos garantir que esses pacotes acabem usando a cópia que já temos na distribuição, se houver. Isso melhora o uso de recursos (a dependência é criada e armazenada apenas uma vez) e permite que a distribuição faça alterações transversais, como aplicar atualizações de segurança para um determinado pacote de software em um único local e fazê-las afetar todo o sistema -- algo que cópias incluídas impedem."

msgid "Take a look at the profile reported by @command{guix size} (@pxref{Invoking guix size}).  This will allow you to notice references to other packages unwillingly retained.  It may also help determine whether to split the package (@pxref{Packages with Multiple Outputs}), and which optional dependencies should be used.  In particular, avoid adding @code{texlive} as a dependency: because of its extreme size, use @code{texlive-local-tree} procedure instead."
msgstr "Dê uma olhada no perfil relatado por @command{guix size} (@pxref{Invoking guix size}). Isso permitirá que você perceba referências a outros pacotes retidos involuntariamente. Também pode ajudar a determinar se deve dividir o pacote (@pxref{Packages with Multiple Outputs}) e quais dependências opcionais devem ser usadas. Em particular, evite adicionar @code{texlive} como uma dependência: devido ao seu tamanho extremo, em vez disso, use o procedimento @code{texlive-local-tree}."

msgid "Check that dependent packages (if applicable) are not affected by the change; @command{guix refresh --list-dependent @var{package}} will help you do that (@pxref{Invoking guix refresh})."
msgstr "Verifique-se os pacotes dependentes (se aplicável) não são afetados pela alteração; @command{guix refresh --list-dependent @var{pacote}} ajudará você a fazer isso (@pxref{Invoking guix refresh})."

msgid "determinism, of build processes"
msgstr "determinismo, de processos de compilação"

msgid "reproducible builds, checking"
msgstr "compilações reproduzíveis, verificação"

msgid "Check whether the package's build process is deterministic.  This typically means checking whether an independent build of the package yields the exact same result that you obtained, bit for bit."
msgstr "Verifique se o processo de compilação do pacote é determinístico. Isso normalmente significa verificar se uma compilação independente do pacote produz o mesmo resultado que você obteve, bit por bit."

msgid "A simple way to do that is by building the same package several times in a row on your machine (@pxref{Invoking guix build}):"
msgstr "Uma maneira simples de fazer isso é compilar o mesmo pacote várias vezes seguidas em sua máquina (@pxref{Invoking guix build}):"

msgid "guix build --rounds=2 my-package\n"
msgstr "guix build --rounds=2 meu-pacote\n"

msgid "This is enough to catch a class of common non-determinism issues, such as timestamps or randomly-generated output in the build result."
msgstr "Isso é suficiente para capturar uma classe de problemas comuns de não-determinismo, como registros de data e hora ou saída gerada aleatoriamente no resultado da compilação."

msgid "Another option is to use @command{guix challenge} (@pxref{Invoking guix challenge}).  You may run it once the package has been committed and built by @code{@value{SUBSTITUTE-SERVER-1}} to check whether it obtains the same result as you did.  Better yet: Find another machine that can build it and run @command{guix publish}.  Since the remote build machine is likely different from yours, this can catch non-determinism issues related to the hardware---e.g., use of different instruction set extensions---or to the operating system kernel---e.g., reliance on @code{uname} or @file{/proc} files."
msgstr "Outra opção é usar @command{guix challenge} (@pxref{Invoking guix challenge}). Você pode executá-lo uma vez que o pacote se tenha sido feito o commit e compilação por @code{SUBSTITUTE-SERVER-1} para verificar se obtém o mesmo resultado que você fez. Melhor ainda: encontre outra máquina que possa compilá-lo e executar @command{guix publish}. Como a máquina de compilação remota provavelmente é diferente da sua, isso pode capturar problemas de não determinismo relacionados ao hardware - por exemplo, uso de extensões de conjunto de instruções diferentes – ou ao kernel do sistema operacional – por exemplo, confiança em @code{uname} ou arquivos de @file{/proc}."

msgid "When writing documentation, please use gender-neutral wording when referring to people, such as @uref{https://en.wikipedia.org/wiki/Singular_they, singular ``they''@comma{} ``their''@comma{} ``them''}, and so forth."
msgstr "Ao escrever documentação, por favor, use palavras de gênero neutras ao se referir a pessoas, como @uref{https://en.wikipedia.org/wiki/Singular_they, singular ``they''@comma{} ``their'' @comma{} ``them''}, e assim por diante."

msgid "Verify that your patch contains only one set of related changes.  Bundling unrelated changes together makes reviewing harder and slower."
msgstr "Verifique se o seu patch contém apenas um conjunto de alterações relacionadas. Agrupar mudanças não relacionadas juntas torna a revisão mais difícil e lenta."

msgid "Examples of unrelated changes include the addition of several packages, or a package update along with fixes to that package."
msgstr "Exemplos de alterações não relacionadas incluem a adição de vários pacotes ou uma atualização de pacote juntamente com correções para esse pacote."

msgid "Please follow our code formatting rules, possibly running @command{guix style} script to do that automatically for you (@pxref{Formatting Code})."
msgstr "Siga nossas regras de formatação de código, possivelmente executando o script @command{guix style} para fazer isso automaticamente para você (@pxref{Formatting Code})."

msgid "When possible, use mirrors in the source URL (@pxref{Invoking guix download}).  Use reliable URLs, not generated ones.  For instance, GitHub archives are not necessarily identical from one generation to the next, so in this case it's often better to clone the repository.  Don't use the @code{name} field in the URL: it is not very useful and if the name changes, the URL will probably be wrong."
msgstr "Quando possível, use espelhos no URL fonte (@pxref{Invoking guix download}). Use URLs confiáveis, não os gerados. Por exemplo, os arquivos do GitHub não são necessariamente idênticos de uma geração para a seguinte, portanto, nesse caso, geralmente é melhor clonar o repositório. Não use o campo @code{name} no URL: não é muito útil e se o nome mudar, o URL provavelmente estará errado."

msgid "Check if Guix builds (@pxref{Building from Git}) and address the warnings, especially those about use of undefined symbols."
msgstr "Verifique se o Guix compila (@pxref{Building from Git}) e resolva os avisos, especialmente aqueles sobre o uso de símbolos indefinidos."

msgid "Make sure your changes do not break Guix and simulate a @command{guix pull} with:"
msgstr "Certifique-se de que suas alterações não quebrem o Guix e simule um @command{guix pull} com:"

msgid "guix pull --url=/path/to/your/checkout --profile=/tmp/guix.master --disable-authentication\n"
msgstr "guix pull --url=/caminho/para/seu/checkout --profile=/tmp/guix.master --disable-authentication\n"

msgid "Configuring Git"
msgstr "Configurando o Git"

msgid "git configuration"
msgstr "Configuração do git"

msgid "If you have not done so already, you may wish to set a name and email that will be associated with your commits (@pxref{telling git your name, , Telling Git your name, git, Git User Manual}).  If you wish to use a different name or email just for commits in this repository, you can use @command{git config --local}, or edit @file{.git/config} in the repository instead of @file{~/.gitconfig}."
msgstr "Se você ainda não fez isso, você pode querer definir um nome e e-mail que serão associados aos seus commits (@pxref{telling git your name, , Telling Git your name, git, Git User Manual}). Se você quiser usar um nome ou e-mail diferente apenas para commits neste repositório, você pode usar @command{git config --local}, ou editar @file{.git/config} no repositório em vez de @file{~/.gitconfig}."

msgid "commit-msg hook"
msgstr "gancho commit-msg"

msgid "Other important Git configuration will automatically be configured when building the project (@pxref{Building from Git}).  A @file{.git/hooks/commit-msg} hook will be installed that embeds @samp{Change-Id} Git @emph{trailers} in your commit messages for traceability purposes.  It is important to preserve these when editing your commit messages, particularly if a first version of your proposed changes was already submitted for review.  If you have a @file{commit-msg} hook of your own you would like to use with Guix, you can place it under the @file{.git/hooks/commit-msg.d/} directory."
msgstr "Outras configurações importantes do Git serão configuradas automaticamente ao construir o projeto (@pxref{Building from Git}). Um hook @file{.git/hooks/commit-msg} será instalado, incorporando @samp{Change-Id} Git @emph{trailers} em suas mensagens de commit para fins de rastreabilidade. É importante preservá-los ao editar suas mensagens de commit, principalmente se uma primeira versão de suas alterações propostas já foi enviada para revisão. Se você tiver um hook @file{commit-msg} próprio que gostaria de usar com o Guix, pode colocá-lo no diretório @file{.git/hooks/commit-msg.d/}."

msgid "This section describes how the Guix project tracks its bug reports, patch submissions and topic branches."
msgstr "Esta seção descreve como o projeto Guix rastreia seus relatórios de bugs, envios de patches e ramificações de tópicos."

msgid "The Issue Tracker"
msgstr "O rastreador de problemas"

msgid "The official bug and patch tracker."
msgstr "O rastreador oficial de bugs e patches."

msgid "Managing Patches and Branches"
msgstr "Gerenciando Patches e Branches"

msgid "How changes to Guix are managed."
msgstr "Como as alterações no Guix são gerenciadas."

msgid "Debbugs User Interfaces"
msgstr "Interfaces de usuário do Debbugs"

msgid "Ways to interact with Debbugs."
msgstr "Maneiras de interagir com Debbugs."

msgid "Cuirass Build Notifications"
msgstr "Notificações de construção de Cuirass"

msgid "Be alerted of any breakage via RSS feeds."
msgstr "Seja alertado sobre qualquer quebra via feeds RSS."

msgid "Debbugs, issue tracking system"
msgstr "Debbugs, sistema de rastreamento de problemas"

msgid "Bug reports (@dfn{issues}) and patch submissions (@dfn{pull requests})  are currently tracked at the @uref{https://codeberg.org/guix/guix, project's home at Codeberg}."
msgstr "Submissão de bugs (@dfn{issues}) e envios de patches (@dfn{pull requests}) são atualmente monitorados no @uref{https://codeberg.org/guix/guix, a página inicial do projeto no Codeberg}."

msgid "branching strategy"
msgstr "estratégia de ramificação"

msgid "rebuild scheduling strategy"
msgstr "estratégia de agendamento de recompilação"

msgid "Submitted patches are picked up and tested by the quality assurance service; the result of that testing eventually shows up on the dashboard at @indicateurl{https://qa.guix.gnu.org/issue/@var{ISSUE_NUMBER}}, where @var{ISSUE_NUMBER} is the number assigned by the issue tracker, currently Debbugs (work is in progress to support Codeberg pull requests).  Leave time for a review, without committing anything."
msgstr "Patches submetidos são coletados e testados pelo serviço de garantia de qualidade; o resultado desse teste eventualmente aparece no painel em @indicateurl{https://qa.guix.gnu.org/issue/@var{NÚMERO_DE_ISSÃO}}, onde @var{NÚMERO_DE_ISSÃO} é o número atribuído pelo rastreador de problemas, que atualmente é o Debbugs (estamos trabalhando para dar suporte á pull requests via Codeberg). Reserve um tempo para uma revisão, sem comprometer nada."

msgid "As an exception, some changes considered ``trivial'' or ``obvious'' may be pushed directly to the @code{master} branch.  This includes changes to fix typos and reverting commits that caused immediate problems.  This is subject to being adjusted, allowing individuals to commit directly on non-controversial changes on parts they’re familiar with."
msgstr "Como exceção, algumas mudanças consideradas ``triviais'' ou ``óbvias'' podem ser enviadas diretamente para o branch @code{master}. Isso inclui mudanças para corrigir erros de digitação e reverter commits que causaram problemas imediatos. Isso está sujeito a ajustes, permitindo que indivíduos se comprometam diretamente com mudanças não controversas em partes com as quais estão familiarizados."

msgid "Changes which affect more than 300 dependent packages (@pxref{Invoking guix refresh}) should first be pushed to a topic branch other than @code{master}; the set of changes should be consistent---e.g., ``GNOME update'', ``NumPy update'', etc.  This allows for testing: the branch will automatically show up at @indicateurl{https://qa.guix.gnu.org/branch/@var{branch}}, with an indication of its build status on various platforms."
msgstr "Alterações que afetam mais de 300 pacotes dependentes (@pxref{Invoking guix refresh}) devem primeiro ser enviadas para um branch de tópico diferente de @code{master}; o conjunto de alterações deve ser consistente, por exemplo, ``GNOME update'', ``NumPy update'', etc. Isso permite testes: o branch aparecerá automaticamente em @indicateurl{https://qa.guix.gnu.org/branch/@var{branch}}, com uma indicação de seu status de compilação em várias plataformas."

msgid "feature branches, coordination"
msgstr "ramos de recursos, coordenação"

msgid "To help coordinate the merging of branches, you must create a new guix-patches issue each time you create a branch (@pxref{The Issue Tracker}).  The title of the issue requesting to merge a branch should have the following format:"
msgstr "Para ajudar a coordenar a fusão de branches, você deve criar um novo problema guix-patches sempre que criar um branch (@pxref{The Issue Tracker}). O título do problema que solicita a fusão de um branch deve ter o seguinte formato:"

msgid "merge requests, template"
msgstr "solicitações de mesclagem, modelo"

msgid "Request for merging \"@var{name}\" branch\n"
msgstr "Solicitação de mesclagem do branch \"@var{name}\"\n"

msgid "The @url{https://qa.guix.gnu.org/, QA infrastructure} recognizes such issues and lists the merge requests on its main page.  The following points apply to managing these branches:"
msgstr "O @url{https://qa.guix.gnu.org/, infraestrutura de QA} reconhece tais problemas e lista as solicitações de mesclagem em sua página principal. Os seguintes pontos se aplicam ao gerenciamento dessas ramificações:"

msgid "The commits on the branch should be a combination of the patches relevant to the branch.  Patches not related to the topic of the branch should go elsewhere."
msgstr "Os commits no branch devem ser uma combinação dos patches relevantes para o branch. Patches não relacionados ao tópico do branch devem ir para outro lugar."

msgid "Any changes that can be made on the master branch, should be made on the master branch.  If a commit can be split to apply part of the changes on master, this is good to do."
msgstr "Quaisquer alterações que possam ser feitas no branch master, devem ser feitas no branch master. Se um commit puder ser dividido para aplicar parte das alterações no master, isso é bom de se fazer."

msgid "It should be possible to re-create the branch by starting from master and applying the relevant patches."
msgstr "Deve ser possível recriar a ramificação iniciando pelo master e aplicando os patches relevantes."

msgid "Avoid merging master in to the branch.  Prefer rebasing or re-creating the branch on top of an updated master revision."
msgstr "Evite mesclar o master no branch. Prefira rebasear ou recriar o branch em cima de uma revisão master atualizada."

msgid "Minimise the changes on master that are missing on the branch prior to merging the branch in to master.  This means that the state of the branch better reflects the state of master should the branch be merged."
msgstr "Minimize as alterações no master que estão faltando no branch antes de mesclar o branch no master. Isso significa que o estado do branch reflete melhor o estado do master caso o branch seja mesclado."

msgid "If you don't have commit access, create the ``Request for merging'' issue and request that someone creates the branch.  Include a list of issues/patches to include on the branch."
msgstr "Se você não tiver acesso de commit, crie o issue ``Request for merging'' e solicite que alguém crie o branch. Inclua uma lista de issues/patches para incluir no branch."

msgid "Normally branches will be merged in a ``first come, first merged'' manner, tracked through the guix-patches issues.  If you agree on a different order with those involved, you can track this by updating which issues block@footnote{You can mark an issue as blocked by another by emailing @email{control@@debbugs.gnu.org} with the following line in the body of the email: @code{block XXXXX by YYYYY}.  Where @code{XXXXX} is the number for the blocked issue, and @code{YYYYY} is the number for the issue blocking it.} which other issues.  Therefore, to know which branch is at the front of the queue, look for the oldest issue, or the issue that isn't @dfn{blocked} by any other branch merges.  An ordered list of branches with the open issues is available at @url{https://qa.guix.gnu.org}."
msgstr "Normalmente, os branches serão mesclados de uma maneira ``primeiro a chegar, primeiro a ser mesclado'', rastreados por meio dos problemas guix-patches. Se você concordar com uma ordem diferente com os envolvidos, você pode rastrear isso atualizando which issues block@footnote{Você pode marcar um issue como bloqueado por outro enviando um e-mail para @email{control@@debbugs.gnu.org} com a seguinte linha no corpo do e-mail: @code{block XXXXX by YYYYY}. Onde @code{XXXXX} é o número do issue bloqueado, e @code{YYYYY} é o número do issue que o está bloqueando.} which other issues. Portanto, para saber qual branch está na frente da fila, procure o issue mais antigo, ou o issue que não está @dfn{bloqueado} por nenhuma outra branch merges. Uma lista ordenada de branches com os issues abertos está disponível em @url{https://qa.guix.gnu.org}."

msgid "Once a branch is at the front of the queue, wait until sufficient time has passed for the build farms to have processed the changes, and for the necessary testing to have happened.  For example, you can check @indicateurl{https://qa.guix.gnu.org/branch/@var{branch}} to see information on some builds and substitute availability."
msgstr "Uma vez que um branch esteja na frente da fila, espere até que tenha passado tempo suficiente para que as farms de build tenham processado as mudanças, e para que os testes necessários tenham acontecido. Por exemplo, você pode verificar @indicateurl{https://qa.guix.gnu.org/branch/@var{branch}} para ver informações sobre alguns builds e disponibilidade de substitutos."

msgid "Once the branch has been merged, the issue should be closed and the branch deleted."
msgstr "Depois que a ramificação for mesclada, o problema deverá ser fechado e a ramificação excluída."

msgid "Warning"
msgstr "Aviso"

msgid "Web interface"
msgstr "Interfaces web"

msgid "mumi, web interface for issues"
msgstr "mumi, interface web para issues"

msgid "A web interface (actually @emph{two} web interfaces!) are available to browse issues:"
msgstr "Uma interface web (na verdade @emph{duas} interfaces web!) está disponível para navegar pelos problemas:"

msgid "@url{https://issues.guix.gnu.org} provides a pleasant interface powered by mumi@footnote{Mumi is a nice piece of software written in Guile, and you can help! See @url{https://codeberg.org/guix/mumi}.} to browse bug reports and patches, and to participate in discussions; mumi also has a command-line interface as we will see below;"
msgstr "@url{https://issues.guix.gnu.org} fornece uma interface agradável alimentada por mumi@footnote{Mumi é um bom software escrito em Guile, e você pode ajudar! Veja @url{https://codeberg.org/guix/mumi}.} para navegar por relatórios de bugs e patches, e para participar de discussões; mumi também tem uma interface de linha de comando como veremos abaixo;"

msgid "@url{https://bugs.gnu.org/guix} lists bug reports;"
msgstr "@url{https://bugs.gnu.org/guix} lista relatórios de bugs;"

msgid "@url{https://bugs.gnu.org/guix-patches} lists patch submissions."
msgstr "@url{https://bugs.gnu.org/guix-patches} lista envios de patches."

msgid "To view discussions related to issue number @var{n}, go to @indicateurl{https://issues.guix.gnu.org/@var{n}} or @indicateurl{https://bugs.gnu.org/@var{n}}."
msgstr "Para visualizar discussões relacionadas ao problema número @var{n}, acesse @indicateurl{https://issues.guix.gnu.org/@var{n}} ou @indicateurl{https://bugs.gnu.org/@var{n}}."

msgid "Command-Line Interface"
msgstr "Interface de linha de comando"

msgid "mumi command-line interface"
msgstr "interface de linha de comando mumi"

msgid "mumi am"
msgstr "mumi am"

msgid "mumi send-email"
msgstr "mumi send-email"

msgid "mumi www"
msgstr "mumi www"

msgid "Mumi also comes with a command-line interface that can be used to search existing issues, open new issues, compose replies, apply and send patches.  You do not need to use Emacs to use the mumi command-line client.  You interact with it only on the command-line."
msgstr "O Mumi também vem com uma interface de linha de comando que pode ser usada para pesquisar problemas existentes, abrir novos problemas, compor respostas, aplicar e enviar patches. Você não precisa usar o Emacs para usar o cliente de linha de comando mumi. Você interage com ele apenas na linha de comando."

msgid "To use the mumi command-line interface, navigate to a local clone of the Guix git repository, and drop into a shell with mumi, git and git:send-email installed."
msgstr "Para usar a interface de linha de comando mumi, navegue até um clone local do repositório git Guix e entre em um shell com mumi, git e git:send-email instalados."

msgid ""
"$ cd guix\n"
"~/guix$ guix shell mumi git git:send-email\n"
msgstr ""
"$ cd guix\n"
"~/guix$ guix shell mumi git git:send-email\n"

msgid "To search for issues, say all open issues about \"zig\", run"
msgstr "Para procurar problemas, diga todos os problemas abertos sobre \"zig\", execute"

msgid ""
"~/guix [env]$ mumi search zig is:open\n"
"\n"
msgstr ""
"~/guix [env]$ mumi search zig is:open\n"
"\n"

msgid ""
"#60889 Add zig-build-system\n"
"opened on 17 Jan 17:37 Z by Ekaitz Zarraga\n"
"#61036 [PATCH 0/3] Update zig to 0.10.1\n"
"opened on 24 Jan 09:42 Z by Efraim Flashner\n"
"#39136 [PATCH] gnu: services: Add endlessh.\n"
"opened on 14 Jan 2020 21:21 by Nicol? Balzarotti\n"
"#60424 [PATCH] gnu: Add python-online-judge-tools\n"
"opened on 30 Dec 2022 07:03 by gemmaro\n"
"#45601 [PATCH 0/6] vlang 0.2 update\n"
"opened on  1 Jan 2021 19:23 by Ryan Prior\n"
msgstr ""
"#60889 Add zig-build-system\n"
"opened on 17 Jan 17:37 Z by Ekaitz Zarraga\n"
"#61036 [PATCH 0/3] Update zig to 0.10.1\n"
"opened on 24 Jan 09:42 Z by Efraim Flashner\n"
"#39136 [PATCH] gnu: services: Add endlessh.\n"
"opened on 14 Jan 2020 21:21 by Nicol? Balzarotti\n"
"#60424 [PATCH] gnu: Add python-online-judge-tools\n"
"opened on 30 Dec 2022 07:03 by gemmaro\n"
"#45601 [PATCH 0/6] vlang 0.2 update\n"
"opened on  1 Jan 2021 19:23 by Ryan Prior\n"

msgid "Pick an issue and make it the \"current\" issue."
msgstr "Escolha uma questão e torne-a a questão \"atual\"."

msgid ""
"~/guix [env]$ mumi current 61036\n"
"\n"
msgstr ""
"~/guix [env]$ mumi current 61036\n"
"\n"

msgid ""
"#61036 [PATCH 0/3] Update zig to 0.10.1\n"
"opened on 24 Jan 09:42 Z by Efraim Flashner\n"
msgstr ""
"#61036 [PATCH 0/3] Update zig to 0.10.1\n"
"opened on 24 Jan 09:42 Z by Efraim Flashner\n"

msgid "Once an issue is the current issue, you can open the issue in a web browser, compose replies, apply patches, send patches, etc. with short succinct commands."
msgstr "Quando um problema é o problema atual, você pode abri-lo em um navegador da web, redigir respostas, aplicar patches, enviar patches, etc. com comandos curtos e sucintos."

msgid "Open the issue in your web browser using"
msgstr "Abra o problema no seu navegador da web usando"

msgid "~/guix [env]$ mumi www\n"
msgstr "~/guix [env]$ mumi www\n"

msgid "Compose a reply using"
msgstr "Redija uma resposta usando"

msgid "~/guix [env]$ mumi compose\n"
msgstr "~/guix [env]$ mumi compose\n"

msgid "Compose a reply and close the issue using"
msgstr "Redija uma resposta e feche o problema usando"

msgid "~/guix [env]$ mumi compose --close\n"
msgstr "~/guix [env]$ mumi compose --close\n"

msgid "@command{mumi compose} opens your mail client by passing @samp{mailto:} URIs to @command{xdg-open}.  So, you need to have @command{xdg-open} set up to open your mail client correctly."
msgstr "@command{mumi compose} abre seu cliente de e-mail passando URIs @samp{mailto:} para @command{xdg-open}. Então, você precisa ter @command{xdg-open} configurado para abrir seu cliente de e-mail corretamente."

msgid "Apply the latest patchset from the issue using"
msgstr "Aplique o patchset mais recente do problema usando"

msgid "~/guix [env]$ mumi am\n"
msgstr "~/guix [env]$ mumi am\n"

msgid "You may also apply a patchset of a specific version (say, v3) using"
msgstr "Você também pode aplicar um patchset de uma versão específica (digamos, v3) usando"

msgid "~/guix [env]$ mumi am v3\n"
msgstr "~/guix [env]$ mumi am v3\n"

msgid "Or, you may apply a patch from a specific e-mail message.  For example, to apply the patch from the 4th message (message index starts from 0), run"
msgstr "Ou você pode aplicar um patch de uma mensagem de e-mail específica. Por exemplo, para aplicar o patch da 4ª mensagem (o índice da mensagem começa em 0), execute"

msgid "~/guix [env]$ mumi am @@4\n"
msgstr "~/guix [env]$ mumi am @@4\n"

msgid "@command{mumi am} is a wrapper around @command{git am}.  You can pass @command{git am} arguments to it after a @samp{--}.  For example, to add a Signed-off-by trailer, run"
msgstr "@command{mumi am} é um wrapper em torno de @command{git am}. Você pode passar argumentos @command{git am} para ele depois de um @samp{--}. Por exemplo, para adicionar um trailer Signed-off-by, execute"

msgid "~/guix [env]$ mumi am -- -s\n"
msgstr "~/guix [env]$ mumi am -- -s\n"

msgid "Create and send patches to the issue using"
msgstr "Crie e envie patches para o problema usando"

msgid ""
"~/guix [env]$ git format-patch origin/master\n"
"~/guix [env]$ mumi send-email foo.patch bar.patch\n"
msgstr ""
"~/guix [env]$ git format-patch origin/master\n"
"~/guix [env]$ mumi send-email foo.patch bar.patch\n"

msgid "Note that you do not have to pass in @samp{--to} or @samp{--cc} arguments to @command{git format-patch}.  @command{mumi send-email} will put them in correctly when sending the patches."
msgstr "Observe que você não precisa passar os argumentos @samp{--to} ou @samp{--cc} para @command{git format-patch}. @command{mumi send-email} os inserirá corretamente ao enviar os patches."

msgid "To open a new issue, run"
msgstr "Para abrir um novo problema, execute"

msgid "~/guix [env]$ mumi new\n"
msgstr "~/guix [env]$ mumi new\n"

msgid "and send an email (using @command{mumi compose}) or patches (using @command{mumi send-email})."
msgstr "e enviar um e-mail (usando @command{mumi compose}) ou patches (usando @command{mumi send-email})."

msgid "@command{mumi send-email} is really a wrapper around @command{git send-email} that automates away all the nitty-gritty of sending patches.  It uses the current issue state to automatically figure out the correct @samp{To} address to send to, other participants to @samp{Cc}, headers to add, etc."
msgstr "@command{mumi send-email} é realmente um wrapper em torno de @command{git send-email} que automatiza todos os detalhes do envio de patches. Ele usa o estado atual do problema para descobrir automaticamente o endereço @samp{To} correto para enviar, outros participantes para @samp{Cc}, cabeçalhos para adicionar, etc."

msgid "Also note that, unlike @command{git send-email}, @command{mumi send-email} works perfectly well with single and multiple patches alike.  It automates away the debbugs dance of sending the first patch, waiting for a response from debbugs and sending the remaining patches.  It does so by sending the first patch, polling the server for a response, and then sending the remaining patches.  This polling can unfortunately take a few minutes.  So, please be patient."
msgstr "Observe também que, diferentemente de @command{git send-email}, @command{mumi send-email} funciona perfeitamente bem com patches únicos e múltiplos. Ele automatiza a dança dos debbugs de enviar o primeiro patch, esperar por uma resposta dos debbugs e enviar os patches restantes. Ele faz isso enviando o primeiro patch, sondando o servidor para uma resposta e, em seguida, enviando os patches restantes. Infelizmente, essa sondagem pode levar alguns minutos. Então, seja paciente."

msgid "Emacs Interface"
msgstr "Interfaces com Emacs"

msgid "If you use Emacs, you may find it more convenient to interact with issues using @file{debbugs.el}, which you can install with:"
msgstr "Se você usa o Emacs, pode achar mais conveniente interagir com problemas usando @file{debbugs.el}, que pode ser instalado com:"

msgid "guix install emacs-debbugs\n"
msgstr "guix install emacs-debbugs\n"

msgid "For example, to list all open issues on @code{guix-patches}, hit:"
msgstr "Por exemplo, para listar todos os problemas abertos em @code{guix-patches}, clique em:"

msgid "@kbd{C-u} @kbd{M-x} debbugs-gnu @kbd{RET} @kbd{RET} guix-patches @kbd{RET} n y\n"
msgstr "@kbd{C-u} @kbd{M-x} debbugs-gnu @kbd{RET} @kbd{RET} guix-patches @kbd{RET} n y\n"

msgid "To search for bugs, @samp{@kbd{M-x} debbugs-gnu-guix-search} can be used."
msgstr "Para procurar bugs, @samp{@kbd{M-x} debbugs-gnu-guix-search} pode ser usado."

msgid "@xref{Top,,, debbugs-ug, Debbugs User Guide}, for more information on this nifty tool!"
msgstr "@xref{Top,,, debbugs-ug, Guia do usuário do Debbugs}, para mais informações sobre esta ferramenta bacana!"

msgid "build event notifications, RSS feed"
msgstr "criar notificações de eventos, feed RSS"

msgid "notifications, build events"
msgstr "notificações, eventos de compilação"

msgid "Cuirass includes @acronym{RSS, Really Simple Syndication} feeds as one of its features (@pxref{Notifications,,,cuirass}).  Since @url{https://ci.guix.gnu.org/, Berlin} runs an instance of Cuirass, this feature can be used to keep track of recently broken or fixed packages caused by changes pushed to the Guix git repository.  Any RSS client can be used.  A good one, included with Emacs, is @xref{Gnus,,,gnus}.  To register the feed, copy its URL, then from the main Gnus buffer, @samp{*Group*}, do the following:"
msgstr "O Cuirass inclui feeds @acronym{RSS, Really Simple Syndication} como um de seus recursos (@pxref{Notifications,,,cuirass}). Como @url{https://ci.guix.gnu.org/, Berlin} executa uma instância do Cuirass, esse recurso pode ser usado para manter o controle de pacotes recentemente quebrados ou corrigidos causados por alterações enviadas ao repositório git do Guix. Qualquer cliente RSS pode ser usado. Um bom, incluído no Emacs, é @xref{Gnus,,,gnus}. Para registrar o feed, copie sua URL e, a partir do buffer principal do Gnus, @samp{*Group*}, faça o seguinte:"

msgid "Gnus, configuration to read CI RSS feeds"
msgstr "Gnus, configuração para ler feeds RSS do CI"

msgid "RSS feeds, Gnus configuration"
msgstr "feed RSS, configuração do Gnus"

msgid ""
"@kbd{G R} https://ci.guix.gnu.org/events/rss/?specification=master RET\n"
"Guix CI - master RET Build events for specification master. RET\n"
msgstr ""
"@kbd{G R} https://ci.guix.gnu.org/events/rss/?specification=master RET\n"
"Guix CI - master RET Build events for specification master. RET\n"

msgid "Then, back at the @samp{*Group*} buffer, press @kbd{s} to save the newly added RSS group.  As for any other Gnus group, you can update its content by pressing the @kbd{g} key.  You should now receive notifications that read like:"
msgstr "Então, de volta ao buffer @samp{*Group*}, pressione @kbd{s} para salvar o grupo RSS recém-adicionado. Assim como para qualquer outro grupo Gnus, você pode atualizar seu conteúdo pressionando a tecla @kbd{g}. Agora você deve receber notificações que dizem algo como:"

msgid ""
" . [ ?: Cuirass ] Build tree-sitter-meson.aarch64-linux on master is fixed.\n"
" . [ ?: Cuirass ] Build rust-pbkdf2.aarch64-linux on master is fixed.\n"
" . [ ?: Cuirass ] Build rust-pbkdf2.x86_64-linux on master is fixed.\n"
msgstr ""
" . [ ?: Cuirass ] Build tree-sitter-meson.aarch64-linux on master is fixed.\n"
" . [ ?: Cuirass ] Build rust-pbkdf2.aarch64-linux on master is fixed.\n"
" . [ ?: Cuirass ] Build rust-pbkdf2.x86_64-linux on master is fixed.\n"

msgid "where each RSS entry contains a link to the Cuirass build details page of the associated build."
msgstr "onde cada entrada RSS contém um link para a página de detalhes da compilação do Cuirass associada."

msgid "teams"
msgstr "equipes"

msgid "To organize work on Guix, including but not just development efforts, the project has a set of @dfn{teams}.  Each team has its own focus and interests and is the primary contact point for questions and contributions in those areas.  A team's primary mission is to coordinate and review the work of individuals in its scope (@pxref{Reviewing the Work of Others}); it can make decisions within its scope, in agreement with other teams whenever there is overlap or a close connection, and in accordance with other project rules such as seeking consensus (@pxref{Making Decisions})."
msgstr "Para organizar o trabalho no Guix, incluindo, mas não apenas, os esforços de desenvolvimento, o projeto tem um conjunto de @dfn{equipes}. Cada equipe tem seu próprio foco e interesses e é o principal ponto de contato para perguntas e contribuições nessas áreas. A principal missão de uma equipe é coordenar e revisar o trabalho de indivíduos em seu escopo (@pxref{Reviewing the Work of Others}); ela pode tomar decisões dentro de seu escopo, em acordo com outras equipes sempre que houver sobreposição ou uma conexão próxima, e de acordo com outras regras do projeto, como buscar consenso (@pxref{Making Decisions})."

msgid "As an example, the Python team is responsible for core Python packaging matters; it can decide to upgrade core Python packages in a dedicated @code{python-team} branch, in collaboration with any team whose scope is directly dependent on Python---e.g., the Science team---and following branching rules (@pxref{Managing Patches and Branches}).  The Documentation team helps review changes to the documentation and can initiate overarching documentation changes.  The Translations team organizes translation of Guix and its manual and coordinates efforts in that area.  The Core team is responsible for the development of core functionality and interfaces of Guix; because of its central nature, some of its work may require soliciting input from the community at large and seeking consensus before enacting decisions that would affect the entire community."
msgstr "Como exemplo, a equipe Python é responsável por questões de empacotamento do núcleo Python; ela pode decidir atualizar os pacotes principais do Python em uma ramificação dedicada @code{python-team}, em colaboração com qualquer equipe cujo escopo seja diretamente dependente do Python --- por exemplo, a equipe Science --- e seguindo regras de ramificação (@pxref{Managing Patches and Branches}). A equipe Documentation ajuda a revisar as alterações na documentação e pode iniciar alterações abrangentes na documentação. A equipe Translations organiza a tradução do Guix e seu manual e coordena os esforços nessa área. A equipe Core é responsável pelo desenvolvimento da funcionalidade principal e das interfaces do Guix; devido à sua natureza central, parte de seu trabalho pode exigir a solicitação de contribuições da comunidade em geral e a busca de consenso antes de promulgar decisões que afetariam toda a comunidade."

msgid "Teams are defined in the @file{etc/teams.scm} file in the Guix repository.  The scope of each team is defined, when applicable, as a set of files or as a regular expression matching file names."
msgstr "As equipes são definidas no arquivo @file{etc/teams.scm} no repositório Guix. O escopo de cada equipe é definido, quando aplicável, como um conjunto de arquivos ou como uma expressão regular que corresponde a nomes de arquivos."

msgid "team membership"
msgstr "membros da equipe"

msgid "Anyone with interest in a team's domain and willing to contribute to its work can apply to become a member by contacting current members by email; commit access is not a precondition.  Membership is formalized by adding the person's name and email address to @file{etc/teams.scm}.  Members who have not been participating in the team's work for one year or more may be removed; they are free to reapply for membership later."
msgstr "Qualquer pessoa interessada no domínio de uma equipe e disposta a contribuir com seu trabalho pode se candidatar para se tornar um membro entrando em contato com os membros atuais por e-mail; acesso de commit não é uma pré-condição. A filiação é formalizada adicionando o nome e endereço de e-mail da pessoa em @file{etc/teams.scm}. Membros que não participam do trabalho da equipe por um ano ou mais podem ser removidos; eles são livres para se candidatar novamente para filiação mais tarde."

msgid "team creation"
msgstr "criação de equipes"

msgid "One or more people may propose the creation of a new team by reaching out to the community by email at @email{guix-devel@@gnu.org}, clarifying the intended scope and purpose.  When consensus is reached on the creation of this team, someone with commit access formalizes its creation by adding it and its initial members to @file{etc/teams.scm}."
msgstr "Uma ou mais pessoas podem propor a criação de uma nova equipe entrando em contato com a comunidade por e-mail em @email{guix-devel@@gnu.org}, esclarecendo o escopo e o propósito pretendidos. Quando o consenso é alcançado sobre a criação desta equipe, alguém com acesso de commit formaliza sua criação adicionando-a e seus membros iniciais a @file{etc/teams.scm}."

msgid "To list existing teams, run the following command from a Guix checkout:"
msgstr "Para listar as equipes existentes, execute o seguinte comando em um checkout do Guix:"

msgid ""
"$ ./etc/teams.scm list-teams\n"
"id: mentors\n"
"name: Mentors\n"
"description: A group of mentors who chaperone contributions by newcomers.\n"
"members:\n"
"+ Charlie Smith <charlie@@example.org>\n"
"@dots{}\n"
msgstr ""
"$ ./etc/teams.scm list-teams\n"
"id: mentors\n"
"name: Mentors\n"
"description: A group of mentors who chaperone contributions by newcomers.\n"
"members:\n"
"+ Charlie Smith <charlie@@example.org>\n"
"@dots{}\n"

msgid "mentoring"
msgstr "mentoria"

msgid "You can run the following command to have the Mentors team put in CC of a patch series:"
msgstr "Você pode executar o seguinte comando para que a equipe Mentors coloque em CC uma série de patches:"

msgid ""
"$ git send-email --to=@var{ISSUE_NUMBER}@@debbugs.gnu.org \\\n"
"  --header-cmd='etc/teams.scm cc-mentors-header-cmd' *.patch\n"
msgstr ""
"$ git send-email --to=@var{NÚMERO_DE_ISSÃO}@@debbugs.gnu.org \\\n"
"  --header-cmd='etc/teams.scm cc-mentors-header-cmd' *.patch\n"

msgid "The appropriate team or teams can also be inferred from the modified files.  For instance, if you want to send the two latest commits of the current Git repository to review, you can run:"
msgstr "A equipe ou equipes apropriadas também podem ser inferidas a partir dos arquivos modificados. Por exemplo, se você quiser enviar os dois últimos commits do repositório Git atual para revisão, você pode executar:"

msgid ""
"$ guix shell -D guix\n"
"[env]$ git send-email --to=@var{ISSUE_NUMBER}@@debbugs.gnu.org -2\n"
msgstr ""
"$ guix shell -D guix\n"
"[env]$ git send-email --to=@var{NÚMERO_DE_ISSÃO}@@debbugs.gnu.org -2\n"

msgid "teams, on Codeberg"
msgstr "equipes, no Codeberg"

msgid "To generate a @file{CODEOWNERS} file, which Forgejo---the software behind Codeberg---uses to determine which team or person should review changes to a given set of files, run:"
msgstr "Para gerar o arquivo @file{CODEOWNERS}, que o Forgejo---o software por trás do Codeberg---usa para determinar qual time ou pessoa deve revisar mudanças feitas a um dado conjunto de arquivos, rode:"

msgid "./etc/teams.scm codeowners > CODEOWNERS\n"
msgstr "./etc/teams.scm codeowners > CODEOWNERS\n"

msgid "decision making"
msgstr "tomando uma decisão"

msgid "consensus seeking"
msgstr "busca de consenso"

msgid "It is expected from all contributors, and even more so from committers, to help build consensus and make decisions based on consensus.  By using consensus, we are committed to finding solutions that everyone can live with.  It implies that no decision is made against significant concerns and these concerns are actively resolved with proposals that work for everyone."
msgstr "Espera-se de todos os contribuidores, e ainda mais dos committers, que ajudem a construir consenso e tomar decisões com base no consenso. Ao usar o consenso, estamos comprometidos em encontrar soluções com as quais todos possam conviver. Isso implica que nenhuma decisão é tomada contra preocupações significativas e essas preocupações são ativamente resolvidas com propostas que funcionam para todos."

msgid "A contributor (who may or may not have commit access) wishing to block a proposal bears a special responsibility for finding alternatives, proposing ideas/code or explain the rationale for the status quo to resolve the deadlock.  To learn what consensus decision making means and understand its finer details, you are encouraged to read @url{https://www.seedsforchange.org.uk/consensus}."
msgstr "Um colaborador (que pode ou não ter acesso de commit) que deseja bloquear uma proposta tem uma responsabilidade especial de encontrar alternativas, propor ideias/código ou explicar a lógica do status quo para resolver o impasse. Para aprender o que significa tomada de decisão por consenso e entender seus detalhes mais sutis, você é encorajado a ler @url{https://www.seedsforchange.org.uk/consensus}."

msgid "commit access, for developers"
msgstr "acesso de confirmação, para desenvolvedores"

msgid "Everyone can contribute to Guix without having commit access (@pxref{Submitting Patches}).  However, for frequent contributors, having write access to the repository can be convenient.  As a rule of thumb, a contributor should have accumulated fifty (50) reviewed commits to be considered as a committer and have sustained their activity in the project for at least 6 months.  This ensures enough interactions with the contributor, which is essential for mentoring and assessing whether they are ready to become a committer.  Commit access should not be thought of as a ``badge of honor'' but rather as a responsibility a contributor is willing to take to help the project."
msgstr "Todos podem contribuir para o Guix sem ter acesso de commit (@pxref{Submitting Patches}). No entanto, para contribuidores frequentes, ter acesso de gravação ao repositório pode ser conveniente. Como regra geral, um contribuidor deve ter acumulado cinquenta (50) commits revisados para ser considerado um committer e ter mantido sua atividade no projeto por pelo menos 6 meses. Isso garante interações suficientes com o contribuidor, o que é essencial para a orientação e avaliação se ele está pronto para se tornar um committer. O acesso de commit não deve ser pensado como um ``emblema de honra'', mas sim como uma responsabilidade que um contribuidor está disposto a assumir para ajudar o projeto."

msgid "Committers are in a position where they enact technical decisions.  Such decisions must be made by @emph{actively building consensus} among interested parties and stakeholders.  @xref{Making Decisions}, for more on that."
msgstr "Os committers estão em uma posição onde eles promulgam decisões técnicas. Tais decisões devem ser tomadas por @emph{construindo ativamente o consenso} entre as partes interessadas e stakeholders. @xref{Making Decisions}, para mais sobre isso."

msgid "The following sections explain how to get commit access, how to be ready to push commits, and the policies and community expectations for commits pushed upstream."
msgstr "As seções a seguir explicam como obter acesso de commit, como estar pronto para enviar commits e as políticas e expectativas da comunidade para commits enviados upstream."

msgid "Applying for Commit Access"
msgstr "Solicitando acesso de confirmação"

msgid "When you deem it necessary, consider applying for commit access by following these steps:"
msgstr "Quando você julgar necessário, considere solicitar acesso de confirmação seguindo estas etapas:"

msgid "Find three committers who would vouch for you.  Each of them should email a statement to @email{guix-maintainers@@gnu.org} (a private alias for the collective of maintainers), signed with their OpenPGP key."
msgstr "Encontre três committers que atestariam por você. Cada um deles deve enviar uma declaração por e-mail para @email{guix-maintainers@@gnu.org} (um alias privado para o coletivo de mantenedores), assinado com sua chave OpenPGP."

msgid "Committers are expected to have had some interactions with you as a contributor and to be able to judge whether you are sufficiently familiar with the project's practices.  It is @emph{not} a judgment on the value of your work, so a refusal should rather be interpreted as ``let's try again later''."
msgstr "Espera-se que os committers tenham tido algumas interações com você como colaborador e sejam capazes de julgar se você está suficientemente familiarizado com as práticas do projeto. Não é um julgamento sobre o valor do seu trabalho, então uma recusa deve ser interpretada como \"vamos tentar novamente mais tarde''."

msgid "Send @email{guix-maintainers@@gnu.org} a message stating your intent, listing the three committers who support your application, signed with the OpenPGP key you will use to sign commits, and giving its fingerprint (see below).  See @uref{https://emailselfdefense.fsf.org/en/}, for an introduction to public-key cryptography with GnuPG."
msgstr "Envie para @email{guix-maintainers@@gnu.org} uma mensagem informando sua intenção, listando os três committers que dão suporte ao seu aplicativo, assinados com a chave OpenPGP que você usará para assinar commits e fornecendo sua impressão digital (veja abaixo). Veja @uref{https://emailselfdefense.fsf.org/en/}, para uma introdução à criptografia de chave pública com GnuPG."

msgid "Set up GnuPG such that it never uses the SHA1 hash algorithm for digital signatures, which is known to be unsafe since 2019, for instance by adding the following line to @file{~/.gnupg/gpg.conf} (@pxref{GPG Esoteric Options,,, gnupg, The GNU Privacy Guard Manual}):"
msgstr "Configure o GnuPG de forma que ele nunca use o algoritmo de hash SHA1 para assinaturas digitais, que é conhecido por ser inseguro desde 2019, por exemplo, adicionando a seguinte linha em @file{~/.gnupg/gpg.conf} (@pxref{GPG Esoteric Options,,, gnupg, The GNU Privacy Guard Manual}):"

msgid "digest-algo sha512\n"
msgstr "digest-algo sha512\n"

msgid "Maintainers ultimately decide whether to grant you commit access, usually following your referrals' recommendation."
msgstr "Os mantenedores decidem, em última instância, se lhe concedem acesso de confirmação, geralmente seguindo a recomendação das suas referências."

msgid "OpenPGP, signed commits"
msgstr "OpenPGP, confirmações assinadas"

msgid "If and once you've been given access, please send a message to @email{guix-devel@@gnu.org} to say so, again signed with the OpenPGP key you will use to sign commits (do that before pushing your first commit).  That way, everyone can notice and ensure you control that OpenPGP key."
msgstr "Se e uma vez que você tenha recebido acesso, envie uma mensagem para @email{guix-devel@@gnu.org} para dizer isso, novamente assinada com a chave OpenPGP que você usará para assinar os commits (faça isso antes de enviar seu primeiro commit). Dessa forma, todos podem notar e garantir que você controle essa chave OpenPGP."

msgid "Important"
msgstr "Importante"

msgid "Before you can push for the first time, maintainers must:"
msgstr "Antes de poder fazer push pela primeira vez, os mantenedores devem:"

msgid "add your OpenPGP key to the @code{keyring} branch;"
msgstr "adicione sua chave OpenPGP à ramificação @code{keyring};"

msgid "add your OpenPGP fingerprint to the @file{.guix-authorizations} file of the branch(es) you will commit to."
msgstr "adicione sua impressão digital OpenPGP ao arquivo @file{.guix-authorizations} da(s) ramificação(ões) para as quais você fará o commit."

msgid "Make sure to read the rest of this section and... profit!"
msgstr "Não deixe de ler o restante desta seção e... lucre!"

msgid "Maintainers are happy to give commit access to people who have been contributing for some time and have a track record---don't be shy and don't underestimate your work!"
msgstr "Os mantenedores ficarão felizes em dar acesso de comprometimento a pessoas que contribuem há algum tempo e têm um histórico. Não seja tímido e não subestime seu trabalho!"

msgid "However, note that the project is working towards a more automated patch review and merging system, which, as a consequence, may lead us to have fewer people with commit access to the main repository.  Stay tuned!"
msgstr "No entanto, observe que o projeto está trabalhando em direção a um sistema de revisão e mesclagem de patches mais automatizado, o que, como consequência, pode nos levar a ter menos pessoas com acesso de commit ao repositório principal. Fique ligado!"

msgid "All commits that are pushed to the central repository on Codeberg must be signed with an OpenPGP key, and the public key should be uploaded to your user account on Codeberg and to public key servers, such as @code{keys.openpgp.org}.  To configure Git to automatically sign commits, run:"
msgstr "Todos os commits que são enviados para o repositório central no Codeberg devem ser assinados com uma chave OpenPGP, e a chave pública deve ser carregada para sua conta de usuário no Codeberg e para servidores de chave pública, como @code{keys.openpgp.org}. Para configurar o Git para assinar commits automaticamente, execute:"

msgid ""
"git config commit.gpgsign true\n"
"\n"
msgstr ""
"git config commit.gpgsign true\n"
"\n"

msgid ""
"# Substitute the fingerprint of your public PGP key.\n"
"git config user.signingkey CABBA6EA1DC0FF33\n"
msgstr ""
"# Substitua a impressão digital da sua chave PGP pública.\n"
"git config user.signingkey CABBA6EA1DC0FF33\n"

msgid "To check that commits are signed with correct key, use:"
msgstr "Para verificar se os commits estão assinados com a chave correta, use:"

msgid "@xref{Building from Git} for running the first authentication of a Guix checkout."
msgstr "@xref{Building from Git} para executar a primeira autenticação de um checkout do Guix."

msgid "To avoid accidentally pushing unsigned or signed with the wrong key commits to Codeberg, make sure to configure Git according to @xref{Configuring Git}."
msgstr "Para evitar enviar acidentalmente commits não assinados ou assinados com a chave errada para o Codeberg, certifique-se de configurar o Git de acordo com @xref{Configuring Git}."

msgid "Commit Policy"
msgstr "Política de Comprometimento"

msgid "If you get commit access, please make sure to follow the policy below (discussions of the policy can take place on @email{guix-devel@@gnu.org})."
msgstr "Se você obtiver acesso de confirmação, certifique-se de seguir a política abaixo (as discussões sobre a política podem ocorrer em @email{guix-devel@@gnu.org})."

msgid "Ensure you're aware of how the changes should be handled (@pxref{Managing Patches and Branches}) prior to being pushed to the repository, especially for the @code{master} branch."
msgstr "Certifique-se de estar ciente de como as alterações devem ser tratadas (@pxref{Managing Patches and Branches}) antes de serem enviadas ao repositório, especialmente para a ramificação @code{master}."

msgid "If you're committing and pushing your own changes, try and wait at least one week (two weeks for more significant changes, up to one month for changes such as removing a package---@pxref{package-removal-policy, Package Removal}) after you send them for review.  After this, if no one else is available to review them and if you're confident about the changes, it's OK to commit."
msgstr "Se você estiver fazendo commit e enviando suas próprias alterações, tente esperar pelo menos uma semana (duas semanas para alterações mais significativas, até um mês para alterações como remover um pacote---@pxref{package-removal-policy, Remoção de Pacotes}) depois de enviá-las para revisão. Depois disso, se ninguém mais estiver disponível para revisá-las e se você estiver confiante sobre as alterações, está tudo bem fazer commit."

msgid "When pushing a commit on behalf of somebody else, please add a @code{Signed-off-by} line at the end of the commit log message---e.g., with @command{git am --signoff}.  This improves tracking of who did what."
msgstr "Ao enviar um commit em nome de outra pessoa, adicione uma linha @code{Signed-off-by} no final da mensagem de log do commit---por exemplo, com @command{git am --signoff}. Isso melhora o rastreamento de quem fez o quê."

msgid "When adding channel news entries (@pxref{Channels, Writing Channel News}), make sure they are well-formed by running the following command right before pushing:"
msgstr "Ao adicionar entradas de notícias do canal (@pxref{Channels, Escrevendo Notícias do Canal}), certifique-se de que elas estejam bem formadas executando o seguinte comando antes de enviar:"

msgid "make check-channel-news\n"
msgstr "make check-channel-news\n"

msgid "Addressing Issues"
msgstr "Abordando questões"

msgid "Peer review (@pxref{Submitting Patches}) and tools such as @command{guix lint} (@pxref{Invoking guix lint}) and the test suite (@pxref{Running the Test Suite}) should catch issues before they are pushed.  Yet, commits that ``break'' functionality might occasionally go through.  When that happens, there are two priorities: mitigating the impact, and understanding what happened to reduce the chance of similar incidents in the future.  The responsibility for both these things primarily lies with those involved, but like everything this is a group effort."
msgstr "A revisão por pares (@pxref{Submitting Patches}) e ferramentas como @command{guix lint} (@pxref{Invoking guix lint}) e o conjunto de testes (@pxref{Running the Test Suite}) devem detectar problemas antes que eles sejam enviados. No entanto, confirmações que ``quebram'' a funcionalidade podem ocasionalmente passar. Quando isso acontece, há duas prioridades: mitigar o impacto e entender o que aconteceu para reduzir a chance de incidentes semelhantes no futuro. A responsabilidade por ambas as coisas recai principalmente sobre os envolvidos, mas, como tudo, este é um esforço de grupo."

msgid "Some issues can directly affect all users---for instance because they make @command{guix pull} fail or break core functionality, because they break major packages (at build time or run time), or because they introduce known security vulnerabilities."
msgstr "Alguns problemas podem afetar diretamente todos os usuários, por exemplo, porque fazem com que @command{guix pull} falhe ou interrompa a funcionalidade principal, porque interrompem pacotes importantes (em tempo de compilação ou execução) ou porque introduzem vulnerabilidades de segurança conhecidas."

msgid "reverting commits"
msgstr "revertendo commits"

msgid "The people involved in authoring, reviewing, and pushing such commit(s) should be at the forefront to mitigate their impact in a timely fashion: by pushing a followup commit to fix it (if possible), or by reverting it to leave time to come up with a proper fix, and by communicating with other developers about the problem."
msgstr "As pessoas envolvidas na criação, revisão e envio de tais confirmações devem estar na vanguarda para mitigar seu impacto em tempo hábil: enviando uma confirmação de acompanhamento para corrigi-lo (se possível) ou revertendo-o para dar tempo de encontrar uma correção adequada e comunicando-se com outros desenvolvedores sobre o problema."

msgid "If these persons are unavailable to address the issue in time, other committers are entitled to revert the commit(s), explaining in the commit log and on the mailing list what the problem was, with the goal of leaving time to the original committer, reviewer(s), and author(s)  to propose a way forward."
msgstr "Se essas pessoas não estiverem disponíveis para resolver o problema a tempo, outros responsáveis pelo commit têm o direito de reverter o(s) commit(s), explicando no log de commits e na lista de discussão qual era o problema, com o objetivo de dar tempo ao responsável pelo commit original, revisor(es) e autor(es) para propor um caminho a seguir."

msgid "Once the problem has been dealt with, it is the responsibility of those involved to make sure the situation is understood.  If you are working to understand what happened, focus on gathering information and avoid assigning any blame.  Do ask those involved to describe what happened, do not ask them to explain the situation---this would implicitly blame them, which is unhelpful.  Accountability comes from a consensus about the problem, learning from it and improving processes so that it's less likely to reoccur."
msgstr "Uma vez que o problema tenha sido resolvido, é responsabilidade dos envolvidos garantir que a situação seja compreendida. Se você estiver trabalhando para entender o que aconteceu, concentre-se em reunir informações e evite atribuir qualquer culpa. Peça aos envolvidos para descrever o que aconteceu, não peça para eles explicarem a situação --- isso os culparia implicitamente, o que não ajuda. A responsabilização vem de um consenso sobre o problema, aprendendo com ele e melhorando os processos para que seja menos provável que ele ocorra novamente."

msgid "Reverting commits"
msgstr "Revertendo commits"

msgid "In order to reduce the possibility of mistakes, committers will have their Codeberg account removed from the Guix Codeberg project and their key removed from @file{.guix-authorizations} after 12 months of inactivity; they can ask to regain commit access by emailing the maintainers, without going through the vouching process."
msgstr "Para reduzir a possibilidade de erros, os responsáveis pelo commit terão suas contas Codeberg removidas do projeto Guix em Codeberg e suas chaves removidas de @file{.guix-authorizations} após 12 meses de inatividade; eles podem solicitar o acesso de commit novamente enviando um e-mail aos mantenedores, sem passar pelo processo de garantia."

msgid "Maintainers@footnote{See @uref{https://guix.gnu.org/en/about} for the current list of maintainers.  You can email them privately at @email{guix-maintainers@@gnu.org}.} may also revoke an individual's commit rights, as a last resort, if cooperation with the rest of the community has caused too much friction---even within the bounds of the project's code of conduct (@pxref{Contributing}).  They would only do so after public or private discussion with the individual and a clear notice.  Examples of behavior that hinders cooperation and could lead to such a decision include:"
msgstr "Mantenedores@footnote{Veja @uref{https://guix.gnu.org/pt-BR/about} para a lista atual de mantenedores. Você pode enviar um e-mail privado para eles em @email{guix-maintainers@@gnu.org}.} também pode revogar os direitos de commit de um indivíduo, como último recurso, se a cooperação com o resto da comunidade tiver causado muito atrito --- mesmo dentro dos limites do código de conduta do projeto (@pxref{Contributing}). Eles só fariam isso após discussão pública ou privada com o indivíduo e um aviso claro. Exemplos de comportamento que dificulta a cooperação e pode levar a tal decisão incluem:"

msgid "repeated violation of the commit policy stated above;"
msgstr "violação repetida da política de compromisso declarada acima;"

msgid "repeated failure to take peer criticism into account;"
msgstr "falha repetida em levar em consideração as críticas dos colegas;"

msgid "breaching trust through a series of grave incidents."
msgstr "quebrando a confiança através de uma série de incidentes graves."

msgid "When maintainers resort to such a decision, they notify developers on @email{guix-devel@@gnu.org}; inquiries may be sent to @email{guix-maintainers@@gnu.org}.  Depending on the situation, the individual may still be welcome to contribute."
msgstr "Quando os mantenedores recorrem a tal decisão, eles notificam os desenvolvedores em @email{guix-devel@@gnu.org}; consultas podem ser enviadas para @email{guix-maintainers@@gnu.org}. Dependendo da situação, o indivíduo ainda pode ser bem-vindo para contribuir."

msgid "Helping Out"
msgstr "Ajudando"

msgid "One last thing: the project keeps moving forward because committers not only push their own awesome changes, but also offer some of their time @emph{reviewing} and pushing other people's changes.  As a committer, you're welcome to use your expertise and commit rights to help other contributors, too!"
msgstr "Uma última coisa: o projeto continua avançando porque os committers não apenas empurram suas próprias mudanças incríveis, mas também oferecem parte do seu tempo @emph{revisando} e empurrando as mudanças de outras pessoas. Como committer, você é bem-vindo para usar sua expertise e direitos de commit para ajudar outros contribuidores também!"

msgid "Review comments should be unambiguous; be as clear and explicit as you can about what you think should be changed, ensuring the author can take action on it.  Please try to keep the following guidelines in mind during review:"
msgstr "Comentários de revisão devem ser inequívocos; seja o mais claro e explícito possível sobre o que você acha que deve ser alterado, garantindo que o autor possa tomar medidas sobre isso. Tente manter as seguintes diretrizes em mente durante a revisão:"

msgid "@emph{Be clear and explicit about changes you are suggesting}, ensuring the author can take action on it.  In particular, it is a good idea to explicitly ask for new revisions when you want it."
msgstr "@emph{Seja claro e explícito sobre as mudanças que você está sugerindo}, garantindo que o autor possa agir sobre isso. Em particular, é uma boa ideia pedir explicitamente por novas revisões quando você quiser."

msgid "@emph{Remain focused: do not change the scope of the work being reviewed.} For example, if the contribution touches code that follows a pattern deemed unwieldy, it would be unfair to ask the submitter to fix all occurrences of that pattern in the code; to put it simply, if a problem unrelated to the patch at hand was already there, do not ask the submitter to fix it."
msgstr "@emph{Mantenha o foco: não altere o escopo do trabalho que está sendo revisado.} Por exemplo, se a contribuição aborda um código que segue um padrão considerado difícil de manejar, seria injusto pedir ao remetente para corrigir todas as ocorrências desse padrão no código; para simplificar, se um problema não relacionado ao patch em questão já estava lá, não peça ao remetente para corrigi-lo."

msgid "@emph{Ensure progress.} As they respond to review, submitters may submit new revisions of their changes; avoid requesting changes that you did not request in the previous round of comments.  Overall, the submitter should get a clear sense of progress; the number of items open for discussion should clearly decrease over time."
msgstr "@emph{Garantir o progresso.} Conforme respondem à revisão, os remetentes podem enviar novas revisões de suas alterações; evite solicitar alterações que você não solicitou na rodada anterior de comentários. No geral, o remetente deve ter uma noção clara do progresso; o número de itens abertos para discussão deve diminuir claramente ao longo do tempo."

msgid "@emph{Aim for finalization.} Reviewing code is time-consuming.  Your goal as a reviewer is to put the process on a clear path towards integration, possibly with agreed-upon changes, or rejection, with a clear and mutually-understood reasoning.  Avoid leaving the review process in a lingering state with no clear way out."
msgstr "@emph{Aim for finalization.} Revisar código consome tempo. Seu objetivo como revisor é colocar o processo em um caminho claro em direção à integração, possivelmente com mudanças acordadas, ou rejeição, com um raciocínio claro e mutuamente compreendido. Evite deixar o processo de revisão em um estado persistente sem uma saída clara."

msgid "LGTM, Looks Good To Me"
msgstr "LGTM, parece bom para mim"

msgid "review tags"
msgstr "tags de revisão"

msgid "Reviewed-by, git trailer"
msgstr "Revisado por, git trailer"

msgid "If the @emph{whole} series (containing multiple commits) looks good to you, reply with @samp{Reviewed-by:@tie{}Your@tie{}Name@tie{}<your-email@@example.com>} to the cover page if it has one, or to the last patch of the series otherwise, adding another @samp{(for the whole series)} comment on the line below to explicit this fact."
msgstr "Se a série @emph{toda} (contendo vários commits) parecer boa para você, responda com @samp{Reviewed-by:@tie{}Your@tie{}Name@tie{}<your-email@@example.com>} para a página de capa, se houver uma, ou para o último patch da série, caso contrário, adicionando outro comentário @samp{(para toda a série)} na linha abaixo para explicitar esse fato."

msgid "If you instead want to mark a @emph{single commit} as reviewed (but not the whole series), simply reply with @samp{Reviewed-by:@tie{}Your@tie{}Name@tie{}<your-email@@example.com>} to that commit message."
msgstr "Se você quiser marcar um @emph{único commit} como revisado (mas não a série inteira), basta responder com @samp{Reviewed-by:@tie{}Your@tie{}Name@tie{}<your-email@@example.com>} para essa mensagem de commit."

msgid "update-guix-package, updating the guix package"
msgstr "update-guix-package, atualizando o pacote guix"

msgid "It is sometimes desirable to update the @code{guix} package itself (the package defined in @code{(gnu packages package-management)}), for example to make new daemon features available for use by the @code{guix-service-type} service type.  In order to simplify this task, the following command can be used:"
msgstr "Às vezes, é desejável atualizar o pacote @code{guix} em si (o pacote definido em @code{(gnu packages package-management)}), por exemplo, para tornar novos recursos de daemon disponíveis para uso pelo tipo de serviço @code{guix-service-type}. Para simplificar essa tarefa, o seguinte comando pode ser usado:"

msgid "make update-guix-package\n"
msgstr "make update-guix-package\n"

msgid "The @code{update-guix-package} make target will use the last known @emph{commit} corresponding to @code{HEAD} in your Guix checkout, compute the hash of the Guix sources corresponding to that commit and update the @code{commit}, @code{revision} and hash of the @code{guix} package definition."
msgstr "O destino de criação do @code{update-guix-package} usará o último @emph{commit} conhecido correspondente ao @code{HEAD} no seu checkout do Guix, calculará o hash das fontes do Guix correspondentes a esse commit e atualizará o @code{commit}, @code{revision} e o hash da definição do pacote @code{guix}."

msgid "To validate that the updated @code{guix} package hashes are correct and that it can be built successfully, the following command can be run from the directory of your Guix checkout:"
msgstr "Para validar se os hashes do pacote @code{guix} atualizados estão corretos e se ele pode ser construído com sucesso, o seguinte comando pode ser executado no diretório do seu checkout Guix:"

msgid "./pre-inst-env guix build guix\n"
msgstr "./pre-inst-env guix build guix\n"

msgid "To guard against accidentally updating the @code{guix} package to a commit that others can't refer to, a check is made that the commit used has already been pushed to the Codeberg-hosted Guix Git repository."
msgstr "Para evitar a atualização acidental do pacote @code{guix} para um commit ao qual outros não podem se referir, é feita uma verificação de que o commit usado já foi enviado para o repositório Git de Guix hospedado em Codeberg."

msgid "This check can be disabled, @emph{at your own peril}, by setting the @code{GUIX_ALLOW_ME_TO_USE_PRIVATE_COMMIT} environment variable.  When this variable is set, the updated package source is also added to the store.  This is used as part of the release process of Guix."
msgstr "Esta verificação pode ser desabilitada, @emph{por sua conta e risco}, definindo a variável de ambiente @code{GUIX_ALLOW_ME_TO_USE_PRIVATE_COMMIT}. Quando esta variável é definida, a fonte do pacote atualizado também é adicionada ao armazém. Isto é usado como parte do processo de lançamento do Guix."

msgid "deprecation policy"
msgstr "política de depreciação"

msgid "As any lively project with a broad scope, Guix changes all the time and at all levels.  Because it's user-extensible and programmable, incompatible changes can directly impact users and make their life harder.  It is thus important to reduce user-visible incompatible changes to a minimum and, when such changes are deemed necessary, to clearly communicate them through a @dfn{deprecation period} so everyone can adapt with minimum hassle.  This section defines the project's commitments for smooth deprecation and describes procedures and mechanisms to honor them."
msgstr "Como qualquer projeto animado com um escopo amplo, o Guix muda o tempo todo e em todos os níveis. Como é extensível e programável pelo usuário, mudanças incompatíveis podem impactar diretamente os usuários e dificultar suas vidas. Portanto, é importante reduzir as mudanças incompatíveis visíveis ao usuário ao mínimo e, quando tais mudanças forem consideradas necessárias, comunicá-las claramente por meio de um @dfn{período de depreciação} para que todos possam se adaptar com o mínimo de problemas. Esta seção define os compromissos do projeto para uma depreciação suave e descreve procedimentos e mecanismos para honrá-los."

msgid "There are several ways to use Guix; how to handle deprecation will depend on each use case.  Those can be roughly categorized like this:"
msgstr "Há várias maneiras de usar Guix; como lidar com a descontinuação dependerá de cada caso de uso. Elas podem ser categorizadas aproximadamente assim:"

msgid "package management exclusively through the command line;"
msgstr "gerenciamento de pacotes exclusivamente através da linha de comando;"

msgid "advanced package management using the manifest and package interfaces;"
msgstr "gerenciamento avançado de pacotes usando as interfaces de manifesto e pacote;"

msgid "Home and System management, using the @code{operating-system} and/or @code{home-environment} interfaces together with the service interfaces;"
msgstr "Gerenciamento de sistema e home, usando as interfaces @code{operating-system} e/ou @code{home-environment} juntamente com as interfaces de serviço;"

msgid "development or use of external tools that use programming interfaces such as the @code{(guix ...)} modules."
msgstr "desenvolvimento ou utilização de ferramentas externas que utilizam interfaces de programação como os módulos @code{(guix ...)}."

msgid "These use cases form a spectrum with varying degrees of coupling---from ``distant'' to tightly coupled.  Based on this insight, we define the following @dfn{deprecation policies} that we consider suitable for each of these levels."
msgstr "Esses casos de uso formam um espectro com vários graus de acoplamento --- de ``distante'' a fortemente acoplado. Com base nesse insight, definimos as seguintes @dfn{políticas de depreciação} que consideramos adequadas para cada um desses níveis."

msgid "Guix sub-commands should be thought of as remaining available ``forever''.  Once a Guix sub-command is to be removed, it should be deprecated first, and then remain available for @b{at least one year} after the first release that deprecated it."
msgstr "Os subcomandos Guix devem ser pensados como permanecendo disponíveis ``para sempre''. Uma vez que um subcomando Guix deve ser removido, ele deve ser descontinuado primeiro, e então permanecer disponível por @b{pelo menos um ano} após o primeiro lançamento que o descontinuou."

msgid "Deprecation should first be announced in the manual and as an entry in @file{etc/news.scm}; additional communication such as a blog post explaining the rationale is welcome.  Months before the scheduled removal date, the command should print a warning explaining how to migrate.  An example of this is the replacement of @command{guix environment} by @command{guix shell}, started in October 2021@footnote{For more details on the @command{guix shell} transition, see @uref{https://guix.gnu.org/en/blog/2021/from-guix-environment-to-guix-shell/}.}."
msgstr "A descontinuação deve ser anunciada primeiro no manual e como uma entrada em @file{etc/news.scm}; comunicações adicionais, como uma postagem de blog explicando a justificativa, são bem-vindas. Meses antes da data de remoção programada, o comando deve imprimir um aviso explicando como migrar. Um exemplo disso é a substituição de @command{guix environment} por @command{guix shell}, iniciada em outubro de 2021@footnote{Para mais detalhes sobre a transição do @command{guix shell}, consulte @uref{https://guix.gnu.org/en/blog/2021/from-guix-environment-to-guix-shell/}.}."

msgid "Because of the broad impact of such a change, we recommend conducting a user survey before enacting a plan."
msgstr "Devido ao amplo impacto de tal mudança, recomendamos realizar uma pesquisa com usuários antes de implementar um plano."

msgid "package deprecation"
msgstr "depreciação de pacotes"

msgid "Package name changes"
msgstr "Mudança de nome de pacotes"

msgid "When a package name changes, it must remain available under its old name for @b{at least one year}.  For example, @code{go-ipfs} was renamed to @code{kubo} following a decision made upstream; to communicate the name change to users, the package module provided this definition:"
msgstr "Quando um nome de pacote muda, ele deve permanecer disponível sob seu nome antigo por @b{pelo menos um ano}. Por exemplo, @code{go-ipfs} foi renomeado para @code{kubo} após uma decisão tomada upstream; para comunicar a mudança de nome aos usuários, o módulo do pacote forneceu esta definição:"

msgid "deprecated-package"
msgstr "deprecated-package"

msgid "package removal policy"
msgstr "pacotes, politica de remoção"

msgid "package-removal-policy"
msgstr "package-removal-policy"

msgid "Package removal"
msgstr "Remoção de pacote"

msgid "Packages whose upstream developers have declared as having reached ``end of life'' or being unmaintained may be removed; likewise, packages that have been @b{failing to build for two months or more} may be removed."
msgstr "Pacotes cujos desenvolvedores originais declararam que atingiram o ``fim da vida útil'' ou não são mantidos podem ser removidos; da mesma forma, pacotes que estão @b{falhando na compilação por dois meses ou mais} podem ser removidos."

msgid "If the package being removed is a ``leaf'' (no other packages depend on it), it may be removed after a @b{one-month review period} of the patch removing it (this applies even when the removal has additional motivations such as security problems affecting the package)."
msgstr "Se o pacote que está sendo removido for um ``leaf'' (nenhum outro pacote depende dele), ele poderá ser removido após um @b{período de revisão de um mês} do patch que o removeu (isso se aplica mesmo quando a remoção tem motivações adicionais, como problemas de segurança que afetam o pacote)."

msgid "When the package being removed is considered popular, whether or not it is a leaf, its deprecation must be announced as an entry in @code{etc/news.scm}."
msgstr "Quando o pacote que está sendo removido é considerado popular, seja ou não uma folha, sua descontinuação deve ser anunciada como uma entrada em @code{etc/news.scm}."

msgid "Package upgrade"
msgstr "Atualização de pacote"

msgid "In the case of packages with many dependents and/or many users, an upgrade may be treated like the @emph{removal} of the previous version."
msgstr "No caso de pacotes com muitos dependentes e/ou muitos usuários, uma atualização pode ser tratada como a @emph{remoção} da versão anterior."

msgid "Examples include major version upgrades of programming language implementations, as we've seen above with Python, and major upgrades of ``big'' libraries such as Qt or GTK."
msgstr "Exemplos incluem grandes atualizações de versões de implementações de linguagens de programação, como vimos acima com Python, e grandes atualizações de bibliotecas ``grandes'' como Qt ou GTK."

msgid "service deprecation"
msgstr "depreciação de serviço"

msgid "Services"
msgstr "Serviços"

msgid "Changes to services for Guix Home and Guix System have a direct impact on user configuration.  For a user, adjusting to interface changes is rarely rewarding, which is why any such change must be clearly communicated in advance through deprecation warnings and documentation."
msgstr "Mudanças nos serviços para Guix Home e Guix System têm um impacto direto na configuração do usuário. Para um usuário, ajustar-se a mudanças de interface raramente é recompensador, e é por isso que qualquer mudança desse tipo deve ser claramente comunicada com antecedência por meio de avisos de descontinuação e documentação."

msgid "Renaming of variables related to service, home, or system configuration must be communicated for at least six months before removal using the @code{(guix deprecation)} mechanisms.  For example, renaming of @code{murmur-configuration} to @code{mumble-server-configuration} was communicated through a series of definitions like this one:"
msgstr "A renomeação de variáveis relacionadas a configuração de serviço, home ou sistema deve ser comunicada por pelo menos seis meses antes da remoção usando os mecanismos @code{(guix deprecation)}. Por exemplo, a renomeação de @code{murmur-configuration} para @code{mumble-server-configuration} foi comunicada por meio de uma série de definições como esta:"

msgid "define-deprecated/public-alias"
msgstr "define-deprecated/public-alias"

msgid ""
"(define-deprecated/public-alias\n"
"  murmur-configuration\n"
"  mumble-server-configuration)\n"
msgstr ""
"(define-deprecated/public-alias\n"
"  murmur-configuration\n"
"  mumble-server-configuration)\n"

msgid "Procedures slated for removal may be defined like this:"
msgstr "Os procedimentos previstos para remoção podem ser definidos assim:"

msgid "define-deprecated"
msgstr "define-deprecated"

msgid ""
"(define-deprecated (elogind-service #:key (config (elogind-configuration)))\n"
"  elogind-service-type\n"
"  (service elogind-service-type config))\n"
msgstr ""
"(define-deprecated (elogind-service #:key (config (elogind-configuration)))\n"
"  elogind-service-type\n"
"  (service elogind-service-type config))\n"

msgid "Record fields, notably fields of service configuration records, must follow a similar deprecation period.  This is usually achieved through @i{ad hoc} means though.  For example, the @code{hosts-file} field of @code{operating-system} was deprecated by adding a @code{sanitized} property that would emit a warning:"
msgstr "Campos de registro, notavelmente campos de registros de configuração de serviço, devem seguir um período de depreciação similar. Isso geralmente é obtido por meio de @i{ad hoc}. Por exemplo, o campo @code{hosts-file} de @code{operating-system} foi depreciado pela adição de uma propriedade @code{sanitized} que emitiria um aviso:"

msgid "When deprecating interfaces in @code{operating-system}, @code{home-environment}, @code{(gnu services)}, or any popular service, the deprecation must come with an entry in @code{etc/news.scm}."
msgstr "Ao descontinuar interfaces em @code{operating-system}, @code{home-environment}, @code{(gnu services)} ou qualquer serviço popular, a descontinuação deve vir com uma entrada em @code{etc/news.scm}."

msgid "deprecation of programming interfaces"
msgstr "depreciação de interface de programação"

msgid "Core interfaces"
msgstr "Interfaces principais"

msgid "Core programming interfaces, in particular the @code{(guix ...)} modules, may be relied on by a variety of external tools and channels.  Any incompatible change must be formally deprecated with @code{define-deprecated}, as shown above, for @b{at least one year} before removal.  The manual must clearly document the new interface and, except in obvious cases, explain how to migrate from the old one."
msgstr "Interfaces de programação principais, em particular os módulos @code{(guix ...)}, podem ser confiáveis por uma variedade de ferramentas e canais externos. Qualquer alteração incompatível deve ser formalmente descontinuada com @code{define-deprecated}, como mostrado acima, por @b{pelo menos um ano} antes da remoção. O manual deve documentar claramente a nova interface e, exceto em casos óbvios, explicar como migrar da antiga."

msgid "As an example, the @code{build-expression->derivation} procedure was superseded by @code{gexp->derivation} and remained available as a deprecated symbol:"
msgstr "Como exemplo, o procedimento @code{build-expression->derivation} foi substituído por @code{gexp->derivation} e permaneceu disponível como um símbolo obsoleto:"

msgid ""
"(define-deprecated (build-expression->derivation store name exp\n"
"                                                 #:key @dots{})\n"
"  gexp->derivation\n"
"  @dots{})\n"
msgstr ""
"(define-deprecated (build-expression->derivation store name exp\n"
"                                                 #:key @dots{})\n"
"  gexp->derivation\n"
"  @dots{})\n"

msgid "Sometimes bindings are moved from one module to another.  In those cases, bindings must be reexported from the original module for at least one year."
msgstr "Às vezes, bindings são movidos de um módulo para outro. Nesses casos, bindings devem ser reexportados do módulo original por pelo menos um ano."

msgid "This section does not cover all possible situations but hopefully allows users to know what to expect and developers to stick to its spirit.  Please email @email{guix-devel@@gnu.org} for any questions."
msgstr "Esta seção não cobre todas as situações possíveis, mas espera-se que permita que os usuários saibam o que esperar e que os desenvolvedores se mantenham fiéis ao seu espírito. Por favor, envie um e-mail para @email{guix-devel@@gnu.org} para quaisquer perguntas."

msgid "documentation"
msgstr "documentation"

msgid "Guix is documented using the Texinfo system.  If you are not yet familiar with it, we accept contributions for documentation in most formats.  That includes plain text, Markdown, Org, etc."
msgstr "Guix é documentado usando o sistema Texinfo. Se você ainda não está familiarizado com ele, aceitamos contribuições para documentação na maioria dos formatos. Isso inclui texto simples, Markdown, Org, etc."

msgid "Documentation contributions can be sent to @email{guix-patches@@gnu.org}.  Prepend @samp{[DOCUMENTATION]} to the subject."
msgstr "Contribuições de documentação podem ser enviadas para @email{guix-patches@@gnu.org}. Adicione @samp{[DOCUMENTATION]} ao assunto."

msgid "When you need to make more than a simple addition to the documentation, we prefer that you send a proper patch as opposed to sending an email as described above.  @xref{Submitting Patches} for more information on how to send your patches."
msgstr "Quando você precisar fazer mais do que uma simples adição à documentação, preferimos que você envie um patch adequado em vez de enviar um e-mail como descrito acima. @xref{Submitting Patches} para obter mais informações sobre como enviar seus patches."

msgid "To modify the documentation, you need to edit @file{doc/guix.texi} and @file{doc/contributing.texi} (which contains this documentation section), or @file{doc/guix-cookbook.texi} for the cookbook.  If you compiled the Guix repository before, you will have many more @file{.texi} files that are translations of these documents.  Do not modify them, the translation is managed through @uref{https://translate.codeberg.org/projects/guix, Weblate}.  @xref{Translating Guix} for more information."
msgstr "Para modificar a documentação, você precisa editar @file{doc/guix.texi} e @file{doc/contributing.texi} (que contém esta seção de documentação), ou @file{doc/guix-cookbook.texi} para o livro de receitas. Se você compilou o repositório Guix antes, você terá muito mais arquivos @file{.texi} que são traduções desses documentos. Não os modifique, a tradução é gerenciada através de @uref{https://translate.codeberg.org/projects/guix, Weblate}. @xref{Translating Guix} para mais informações."

msgid "To render documentation, you must first make sure that you ran @command{./configure} in your source tree (@pxref{Running Guix Before It Is Installed}).  After that you can run one of the following commands:"
msgstr "Para renderizar a documentação, você deve primeiro certificar-se de que executou @command{./configure} na sua árvore de origem (@pxref{Running Guix Before It Is Installed}). Depois disso, você pode executar um dos seguintes comandos:"

msgid "@samp{make doc/guix.info} to compile the Info manual."
msgstr "@samp{make doc/guix.info} para compilar o manual de informações."

msgid "You can check it with @command{info doc/guix.info}."
msgstr "Você pode verificar com @command{info doc/guix.info}."

msgid "@samp{make doc/guix.html} to compile the HTML version."
msgstr "@samp{make doc/guix.html} para compilar a versão HTML."

msgid "You can point your browser to the relevant file in the @file{doc/guix.html} directory."
msgstr "Você pode apontar seu navegador para o arquivo relevante no diretório @file{doc/guix.html}."

msgid "@samp{make doc/guix-cookbook.info} for the cookbook Info manual."
msgstr "@samp{make doc/guix-cookbook.info} para o manual de informações do livro de receitas."

msgid "@samp{make doc/guix-cookbook.html} for the cookbook HTML version."
msgstr "@samp{make doc/guix-cookbook.html} para a versão HTML do livro de receitas."

msgid "translation"
msgstr "tradução"

msgid "l10n"
msgstr "l10n"

msgid "i18n"
msgstr "i18n"

msgid "native language support"
msgstr "suporte a idioma nativo"

msgid "Writing code and packages is not the only way to provide a meaningful contribution to Guix.  Translating to a language you speak is another example of a valuable contribution you can make.  This section is designed to describe the translation process.  It gives you advice on how you can get involved, what can be translated, what mistakes you should avoid and what we can do to help you!"
msgstr "Escrever código e pacotes não é a única maneira de fornecer uma contribuição significativa para o Guix. Traduzir para um idioma que você fala é outro exemplo de uma contribuição valiosa que você pode fazer. Esta seção foi criada para descrever o processo de tradução. Ela dá conselhos sobre como você pode se envolver, o que pode ser traduzido, quais erros você deve evitar e o que podemos fazer para ajudar você!"

msgid "Guix is a big project that has multiple components that can be translated.  We coordinate the translation effort on a @uref{https://translate.codeberg.org/projects/guix/,Weblate instance} hosted by Codeberg.  You will need an account to submit translations."
msgstr "Guix é um grande projeto que tem vários componentes que podem ser traduzidos. Nós coordenamos o esforço de tradução em uma instância @uref{https://translate.codeberg.org/projects/guix/,Weblate} hospedada por Codeberg. Você precisará de uma conta para enviar traduções."

msgid "Some of the software packaged in Guix also contain translations.  We do not host a translation platform for them.  If you want to translate a package provided by Guix, you should contact their developers or find the information on their website.  As an example, you can find the homepage of the @code{hello} package by typing @command{guix show hello}.  On the ``homepage'' line, you will see @url{https://www.gnu.org/software/hello/} as the homepage."
msgstr "Alguns dos softwares empacotados no Guix também contêm traduções. Não hospedamos uma plataforma de tradução para eles. Se você quiser traduzir um pacote fornecido pelo Guix, entre em contato com os desenvolvedores ou encontre as informações no site deles. Como exemplo, você pode encontrar a homepage do pacote @code{hello} digitando @command{guix show hello}. Na linha \"homepage'', você verá @url{https://www.gnu.org/software/hello/} como a homepage."

msgid "Many GNU and non-GNU packages can be translated on the @uref{https://translationproject.org,Translation Project}.  Some projects with multiple components have their own platform.  For instance, GNOME has its own platform, @uref{https://l10n.gnome.org/,Damned Lies}."
msgstr "Muitos pacotes GNU e não-GNU podem ser traduzidos no @uref{https://translationproject.org,Translation Project}. Alguns projetos com múltiplos componentes têm sua própria plataforma. Por exemplo, o GNOME tem sua própria plataforma, @uref{https://l10n.gnome.org/,Damned Lies}."

msgid "Guix has five components hosted on Weblate."
msgstr "O Guix tem cinco componentes hospedados no Weblate."

msgid "@code{guix} contains all the strings from the Guix software (the"
msgstr "@code{guix} contém todas as strings do software Guix (o"

msgid "guided system installer, the package manager, etc), excluding packages."
msgstr "instalador de sistema guiado, gerenciador de pacotes, etc.), excluindo pacotes."

msgid "@code{packages} contains the synopsis (single-sentence description"
msgstr "@code{packages} contém a sinopse (descrição de uma única frase"

msgid "of a package) and description (longer description) of packages in Guix."
msgstr "de um pacote) e descrição (descrição mais longa) de pacotes no Guix."

msgid "@code{website} contains the official Guix website, except for"
msgstr "@code{website} contém o site oficial do Guix, exceto para"

msgid "blog posts and multimedia content."
msgstr "postagens de blog e conteúdo multimídia."

msgid "@code{documentation-manual} corresponds to this manual."
msgstr "@code{documentation-manual} corresponde a este manual."

msgid "@code{documentation-cookbook} is the component for the cookbook."
msgstr "@code{documentation-cookbook} é o componente do livro de receitas."

msgid "General Directions"
msgstr "Direções gerais"

msgid "Once you get an account, you should be able to select a component from @uref{https://translate.codeberg.org/projects/guix/,the guix project}, and select a language.  If your language does not appear in the list, go to the bottom and click on the ``Start new translation'' button.  Select the language you want to translate to from the list, to start your new translation."
msgstr "Depois de obter uma conta, você deve conseguir selecionar um componente do @uref{https://translate.codeberg.org/projects/guix/, o projeto guix} e selecionar um idioma. Se seu idioma não aparecer na lista, vá até o final e clique no botão \"niciar nova tradução''. Selecione o idioma para o qual deseja traduzir na lista para iniciar sua nova tradução."

msgid "Like lots of other free software packages, Guix uses @uref{https://www.gnu.org/software/gettext,GNU Gettext} for its translations, with which translatable strings are extracted from the source code to so-called PO files."
msgstr "Como muitos outros pacotes de software livre, o Guix usa @uref{https://www.gnu.org/software/gettext,GNU Gettext} para suas traduções, com as quais sequências traduzíveis são extraídas do código-fonte para os chamados arquivos PO."

msgid "Even though PO files are text files, changes should not be made with a text editor but with PO editing software.  Weblate integrates PO editing functionality.  Alternatively, translators can use any of various free-software tools for filling in translations, of which @uref{https://poedit.net/,Poedit} is one example, and (after logging in)  @uref{https://docs.weblate.org/en/latest/user/files.html,upload} the changed file.  There is also a special @uref{https://www.emacswiki.org/emacs/PoMode,PO editing mode} for users of GNU Emacs.  Over time translators find out what software they are happy with and what features they need."
msgstr "Embora os arquivos PO sejam arquivos de texto, as alterações não devem ser feitas com um editor de texto, mas com um software de edição PO. O Weblate integra a funcionalidade de edição PO. Como alternativa, os tradutores podem usar qualquer uma das várias ferramentas de software livre para preencher traduções, das quais @uref{https://poedit.net/,Poedit} é um exemplo, e (após efetuar login) @uref{https://docs.weblate.org/en/latest/user/files.html,upload} o arquivo alterado. Há também um @uref{https://www.emacswiki.org/emacs/PoMode,modo de edição PO} especial para usuários do GNU Emacs. Com o tempo, os tradutores descobrem com qual software estão satisfeitos e quais recursos precisam."

msgid "On Weblate, you will find various links to the editor, that will show various subsets (or all) of the strings.  Have a look around and at the @uref{https://docs.weblate.org/en/latest/,documentation} to familiarize yourself with the platform."
msgstr "No Weblate, você encontrará vários links para o editor, que mostrarão vários subconjuntos (ou todos) das strings. Dê uma olhada ao redor e na @uref{https://docs.weblate.org/en/latest/,documentation} para se familiarizar com a plataforma."

msgid "Translation Components"
msgstr "Componentes de tradução"

msgid "In this section, we provide more detailed guidance on the translation process, as well as details on what you should or should not do.  When in doubt, please contact us, we will be happy to help!"
msgstr "Nesta seção, fornecemos orientações mais detalhadas sobre o processo de tradução, bem como detalhes sobre o que você deve ou não fazer. Em caso de dúvida, entre em contato conosco, ficaremos felizes em ajudar!"

msgid "Guix is written in the Guile programming language, and some strings contain special formatting that is interpreted by Guile.  These special formatting should be highlighted by Weblate.  They start with @code{~} followed by one or more characters."
msgstr "Guix é escrito na linguagem de programação Guile, e algumas strings contêm formatação especial que é interpretada pelo Guile. Essas formatações especiais devem ser destacadas pelo Weblate. Elas começam com @code{~} seguido por um ou mais caracteres."

msgid "When printing the string, Guile replaces the special formatting symbols with actual values.  For instance, the string @samp{ambiguous package specification `~a'} would be substituted to contain said package specification instead of @code{~a}.  To properly translate this string, you must keep the formatting code in your translation, although you can place it where it makes sense in your language.  For instance, the French translation says @samp{spécification du paquet « ~a » ambiguë} because the adjective needs to be placed in the end of the sentence."
msgstr "Ao imprimir a string, Guile substitui os símbolos especiais de formatação por valores reais. Por exemplo, a string @samp{ambiguous package specification `~a'} seria substituída para conter a dita especificação de pacote em vez de @code{~a}. Para traduzir corretamente essa string, você deve manter o código de formatação em sua tradução, embora você possa colocá-lo onde fizer sentido em seu idioma. Por exemplo, a tradução francesa diz @samp{spécification du paquet « ~a » ambiguë} porque o adjetivo precisa ser colocado no final da frase."

msgid "If there are multiple formatting symbols, make sure to respect the order.  Guile does not know in which order you intended the string to be read, so it will substitute the symbols in the same order as the English sentence."
msgstr "Se houver vários símbolos de formatação, certifique-se de respeitar a ordem. O Guile não sabe em qual ordem você pretendia que a string fosse lida, então ele substituirá os símbolos na mesma ordem da frase em inglês."

msgid "As an example, you cannot translate @samp{package '~a' has been superseded by '~a'} by @samp{'~a' supersedes package '~a'}, because the meaning would be reversed.  If @var{foo} is superseded by @var{bar}, the translation would read @samp{'foo' supersedes package 'bar'}.  To work around this problem, it is possible to use more advanced formatting to select a given piece of data, instead of following the default English order.  @xref{Formatted Output,,, guile, GNU Guile Reference Manual}, for more information on formatting in Guile."
msgstr "Por exemplo, você não pode traduzir @samp{package '~a' has been superseded by '~a'} como @samp{'~a' supersedes package '~a'}, porque o significado seria invertido. Se @var{foo} for substituído por @var{bar}, a tradução seria @samp{'foo' supersedes package 'bar'}. Para contornar esse problema, é possível usar uma formatação mais avançada para selecionar um dado pedaço de dados, em vez de seguir a ordem padrão em inglês. @xref{Formatted Output,,, guile, GNU Guile Reference Manual}, para mais informações sobre formatação no Guile."

msgid "packages"
msgstr "pacotes"

msgid "Package descriptions occasionally contain Texinfo markup (@pxref{Synopses and Descriptions}).  Texinfo markup looks like @samp{@@code@{rm -rf@}}, @samp{@@emph@{important@}}, etc.  When translating, please leave markup as is."
msgstr "As descrições de pacotes ocasionalmente contêm marcação Texinfo (@pxref{Synopses and Descriptions}). A marcação Texinfo se parece com @samp{@@code@{rm -rf@}}, @samp{@@emph@{important@}}, etc. Ao traduzir, deixe a marcação como está."

msgid "The characters after ``@@'' form the name of the markup, and the text between ``@{'' and ``@}'' is its content.  In general, you should not translate the content of markup like @code{@@code}, as it contains literal code that do not change with language.  You can translate the content of formatting markup such as @code{@@emph}, @code{@@i}, @code{@@itemize}, @code{@@item}.  However, do not translate the name of the markup, or it will not be recognized.  Do not translate the word after @code{@@end}, it is the name of the markup that is closed at this position (e.g.@: @code{@@itemize ... @@end itemize})."
msgstr "Os caracteres após ``@@'' formam o nome da marcação, e o texto entre ``@{'' e ``@}'' é seu conteúdo. Em geral, você não deve traduzir o conteúdo de uma marcação como @code{@@code}, pois ela contém código literal que não muda com o idioma. Você pode traduzir o conteúdo de uma marcação de formatação como @code{@@emph}, @code{@@i}, @code{@@itemize}, @code{@@item}. No entanto, não traduza o nome da marcação, ou ela não será reconhecida. Não traduza a palavra após @code{@@end}, é o nome da marcação que é fechado nesta posição (por exemplo, @code{@@itemize ... @@end itemize})."

msgid "documentation-manual and documentation-cookbook"
msgstr "documentation-manual e documentation-cookbook"

msgid "The first step to ensure a successful translation of the manual is to find and translate the following strings @emph{first}:"
msgstr "O primeiro passo para garantir uma tradução bem-sucedida do manual é encontrar e traduzir as seguintes strings @emph{primeiro}:"

msgid "@code{version.texi}: Translate this string as @code{version-xx.texi},"
msgstr "@code{version.texi}: Traduza esta string como @code{version-xx.texi},"

msgid "where @code{xx} is your language code (the one shown in the URL on weblate)."
msgstr "onde @code{xx} é o código do seu idioma (aquele mostrado na URL no weblate)."

msgid "@code{contributing.texi}: Translate this string as"
msgstr "@code{contributing.texi}: Traduzir esta string como"

msgid "@code{contributing.xx.texi}, where @code{xx} is the same language code."
msgstr "@code{contributing.xx.texi}, onde @code{xx} é o mesmo código de idioma."

msgid "@code{Top}: Do not translate this string, it is important for Texinfo."
msgstr "@code{Top}: Não traduza esta string, ela é importante para o Texinfo."

msgid "If you translate it, the document will be empty (missing a Top node).  Please look for it, and register @code{Top} as its translation."
msgstr "Se você traduzi-lo, o documento estará vazio (faltando um nó Top). Por favor, procure por ele e registre @code{Top} como sua tradução."

msgid "Translating these strings first ensure we can include your translation in the guix repository without breaking the make process or the @command{guix pull} machinery."
msgstr "Traduzir essas strings primeiro garante que podemos incluir sua tradução no repositório guix sem interromper o processo de criação ou a máquina @command{guix pull}."

msgid "The manual and the cookbook both use Texinfo.  As for @code{packages}, please keep Texinfo markup as is.  There are more possible markup types in the manual than in the package descriptions.  In general, do not translate the content of @code{@@code}, @code{@@file}, @code{@@var}, @code{@@value}, etc.  You should translate the content of formatting markup such as @code{@@emph}, @code{@@i}, etc."
msgstr "O manual e o livro de receitas usam Texinfo. Quanto a @code{packages}, mantenha a marcação Texinfo como está. Há mais tipos de marcação possíveis no manual do que nas descrições de pacotes. Em geral, não traduza o conteúdo de @code{@@code}, @code{@@file}, @code{@@var}, @code{@@value}, etc. Você deve traduzir o conteúdo da marcação de formatação, como @code{@@emph}, @code{@@i}, etc."

msgid "The manual contains sections that can be referred to by name by @code{@@ref}, @code{@@xref} and @code{@@pxref}.  We have a mechanism in place so you do not have to translate their content.  If you keep the English title, we will automatically replace it with your translation of that title.  This ensures that Texinfo will always be able to find the node. If you decide to change the translation of the title, the references will automatically be updated and you will not have to update them all yourself."
msgstr "O manual contém seções que podem ser referenciadas pelo nome por @code{@@ref}, @code{@@xref} e @code{@@pxref}. Temos um mecanismo em vigor para que você não tenha que traduzir o conteúdo delas. Se você mantiver o título em inglês, nós o substituiremos automaticamente pela sua tradução desse título. Isso garante que o Texinfo sempre será capaz de encontrar o nó. Se você decidir alterar a tradução do título, as referências serão atualizadas automaticamente e você não terá que atualizá-las todas sozinho."

msgid "When translating references from the cookbook to the manual, you need to replace the name of the manual and the name of the section.  For instance, to translate @code{@@pxref@{Defining Packages,,, guix, GNU Guix Reference Manual@}}, you would replace @code{Defining Packages} with the title of that section in the translated manual @emph{only} if that title is translated.  If the title is not translated in your language yet, do not translate it here, or the link will be broken.  Replace @code{guix} with @code{guix.xx} where @code{xx} is your language code.  @code{GNU Guix Reference Manual} is the text of the link.  You can translate it however you wish."
msgstr "Ao traduzir referências do livro de receitas para o manual, você precisa substituir o nome do manual e o nome da seção. Por exemplo, para traduzir @code{@@pxref@{Defining Packages,,, guix, GNU Guix Reference Manual@}}, você substituiria @code{Defining Packages} pelo título daquela seção no manual traduzido @emph{somente} se aquele título estiver traduzido. Se o título ainda não estiver traduzido para o seu idioma, não o traduza aqui, ou o link será quebrado. Substitua @code{guix} por @code{guix.xx} onde @code{xx} é o código do seu idioma. @code{GNU Guix Reference Manual} é o texto do link. Você pode traduzi-lo como quiser."

msgid "website"
msgstr "website"

msgid "The website pages are written using SXML, an s-expression version of HTML, the basic language of the web.  We have a process to extract translatable strings from the source, and replace complex s-expressions with a more familiar XML markup, where each markup is numbered.  Translators can arbitrarily change the ordering, as in the following example."
msgstr "As páginas do site são escritas usando SXML, uma versão s-expression do HTML, a linguagem básica da web. Temos um processo para extrair strings traduzíveis da fonte e substituir s-expressions complexas por uma marcação XML mais familiar, onde cada marcação é numerada. Os tradutores podem alterar arbitrariamente a ordem, como no exemplo a seguir."

msgid ""
"#. TRANSLATORS: Defining Packages is a section name\n"
"#. in the English (en) manual.\n"
"#: apps/base/templates/about.scm:64\n"
"msgid \"Packages are <1>defined<1.1>en</1.1><1.2>Defining-Packages.html</1.2></1> as native <2>Guile</2> modules.\"\n"
"msgstr \"Pakete werden als reine <2>Guile</2>-Module <1>definiert<1.1>de</1.1><1.2>Pakete-definieren.html</1.2></1>.\"\n"
msgstr ""
"#. TRANSLATORS: Defining Packages is a section name\n"
"#. in the English (en) manual.\n"
"#: apps/base/templates/about.scm:64\n"
"msgid \"Packages are <1>defined<1.1>en</1.1><1.2>Defining-Packages.html</1.2></1> as native <2>Guile</2> modules.\"\n"
"msgstr \"Pakete werden als reine <2>Guile</2>-Module <1>definiert<1.1>de</1.1><1.2>Pakete-definieren.html</1.2></1>.\"\n"

msgid "Note that you need to include the same markups.  You cannot skip any."
msgstr "Note que você precisa incluir as mesmas marcações. Você não pode pular nenhuma."

msgid "In case you make a mistake, the component might fail to build properly with your language, or even make guix pull fail.  To prevent that, we have a process in place to check the content of the files before pushing to our repository.  We will not be able to update the translation for your language in Guix, so we will notify you (through weblate and/or by email) so you get a chance to fix the issue."
msgstr "Caso você cometa um erro, o componente pode falhar ao construir corretamente com seu idioma, ou até mesmo fazer o guix pull falhar. Para evitar isso, temos um processo em vigor para verificar o conteúdo dos arquivos antes de enviar para nosso repositório. Não poderemos atualizar a tradução para seu idioma no Guix, então iremos notificá-lo (por meio do weblate e/ou por e-mail) para que você tenha a chance de corrigir o problema."

msgid "Outside of Weblate"
msgstr "Fora do Weblate"

msgid "Currently, some parts of Guix cannot be translated on Weblate, help wanted!"
msgstr "Atualmente, algumas partes do Guix não podem ser traduzidas no Weblate. Precisamos de ajuda!"

msgid "@command{guix pull} news can be translated in @file{news.scm}, but is not"
msgstr "@command{guix pull} news pode ser traduzido em @file{news.scm}, mas não é"

msgid "available from Weblate.  If you want to provide a translation, you can prepare a patch as described above, or simply send us your translation with the name of the news entry you translated and your language. @xref{Writing Channel News}, for more information about channel news."
msgstr "disponível no Weblate. Se você quiser fornecer uma tradução, pode preparar um patch conforme descrito acima, ou simplesmente nos enviar sua tradução com o nome da entrada de notícias que você traduziu e seu idioma. @xref{Writing Channel News}, para mais informações sobre notícias do canal."

msgid "Guix blog posts cannot currently be translated."
msgstr "As postagens do blog Guix não podem ser traduzidas no momento."

msgid "The installer script (for foreign distributions) is entirely in English."
msgstr "O script do instalador (para distribuições estrangeiras) é inteiramente em inglês."

msgid "Some of the libraries Guix uses cannot be translated or are translated"
msgstr "Algumas das bibliotecas que o Guix usa não podem ser traduzidas ou são traduzidas"

msgid "outside of the Guix project.  Guile itself is not internationalized."
msgstr "fora do projeto Guix. O Guile em si não é internacionalizado."

msgid "Other manuals linked from this manual or the cookbook might not be"
msgstr "Outros manuais vinculados a este manual ou ao livro de receitas podem não estar disponíveis"

msgid "translated."
msgstr "traduzido."

msgid "Conditions for Inclusion"
msgstr "Condições de inclusão"

msgid "There are no conditions for adding new translations of the @code{guix} and @code{guix-packages} components, other than they need at least one translated string.  New languages will be added to Guix as soon as possible.  The files may be removed if they fall out of sync and have no more translated strings."
msgstr "Não há condições para adicionar novas traduções dos componentes @code{guix} e @code{guix-packages}, além de que eles precisam de pelo menos uma string traduzida. Novos idiomas serão adicionados ao Guix o mais rápido possível. Os arquivos podem ser removidos se ficarem fora de sincronia e não tiverem mais strings traduzidas."

msgid "Given that the web site is dedicated to new users, we want its translation to be as complete as possible before we include it in the language menu.  For a new language to be included, it needs to reach at least 80% completion.  When a language is included, it may be removed in the future if it stays out of sync and falls below 60% completion."
msgstr "Dado que o site é dedicado a novos usuários, queremos que sua tradução esteja o mais completa possível antes de incluí-la no menu de idiomas. Para que um novo idioma seja incluído, ele precisa atingir pelo menos 80% de conclusão. Quando um idioma é incluído, ele pode ser removido no futuro se ficar fora de sincronia e ficar abaixo de 60% de conclusão."

msgid "The manual and cookbook are automatically added in the default compilation target.  Every time we synchronize translations, developers need to recompile all the translated manuals and cookbooks.  This is useless for what is essentially the English manual or cookbook.  Therefore, we will only include a new language when it reaches 10% completion in the component.  When a language is included, it may be removed in the future if it stays out of sync and falls below 5% completion."
msgstr "O manual e o livro de receitas são adicionados automaticamente no destino de compilação padrão. Toda vez que sincronizamos traduções, os desenvolvedores precisam recompilar todos os manuais e livros de receitas traduzidos. Isso é inútil para o que é essencialmente o manual ou livro de receitas em inglês. Portanto, só incluiremos um novo idioma quando ele atingir 10% de conclusão no componente. Quando um idioma é incluído, ele pode ser removido no futuro se ficar fora de sincronia e cair abaixo de 5% de conclusão."

msgid "Translation Infrastructure"
msgstr "Infraestrutura de tradução"

msgid "Weblate is backed by a git repository from which it discovers new strings to translate and pushes new and updated translations.  Normally, it would be enough to give it commit access to our repositories.  However, we decided to use a separate repository for two reasons.  First, we would have to give Weblate commit access and authorize its signing key, but we do not trust it in the same way we trust guix developers, especially since we do not manage the instance ourselves.  Second, if translators mess something up, it can break the generation of the website and/or guix pull for all our users, independently of their language."
msgstr "O Weblate é apoiado por um repositório git do qual ele descobre novas strings para traduzir e envia traduções novas e atualizadas. Normalmente, seria suficiente dar a ele acesso de commit para nossos repositórios. No entanto, decidimos usar um repositório separado por dois motivos. Primeiro, teríamos que dar ao Weblate acesso de commit e autorizar sua chave de assinatura, mas não confiamos nele da mesma forma que confiamos nos desenvolvedores do guix, especialmente porque não gerenciamos a instância nós mesmos. Segundo, se os tradutores bagunçarem alguma coisa, isso pode quebrar a geração do site e/ou o guix pull para todos os nossos usuários, independentemente do idioma deles."

msgid "For these reasons, we use a dedicated repository to host translations, and we synchronize it with our guix and artworks repositories after checking no issue was introduced in the translation."
msgstr "Por esses motivos, usamos um repositório dedicado para hospedar as traduções e o sincronizamos com nossos repositórios guix e artworks após verificar se nenhum problema foi introduzido na tradução."

msgid "Developers can download the latest PO files from weblate in the Guix repository by running the @command{make download-po} command.  It will automatically download the latest files from weblate, reformat them to a canonical form, and check they do not contain issues.  The manual needs to be built again to check for additional issues that might crash Texinfo."
msgstr "Os desenvolvedores podem baixar os arquivos PO mais recentes do weblate no repositório Guix executando o comando @command{make download-po}. Ele baixará automaticamente os arquivos mais recentes do weblate, os reformatará para um formato canônico e verificará se eles não contêm problemas. O manual precisa ser construído novamente para verificar se há problemas adicionais que podem travar o Texinfo."

msgid "Before pushing new translation files, developers should add them to the make machinery so the translations are actually available.  The process differs for the various components."
msgstr "Antes de enviar novos arquivos de tradução, os desenvolvedores devem adicioná-los à maquinaria de make para que as traduções estejam realmente disponíveis. O processo difere para os vários componentes."

msgid "New po files for the @code{guix} and @code{packages} components must"
msgstr "Novos arquivos po para os componentes @code{guix} e @code{packages} devem"

msgid "be registered by adding the new language to @file{po/guix/LINGUAS} or @file{po/packages/LINGUAS}."
msgstr "ser registrado adicionando o novo idioma em @file{po/guix/LINGUAS} ou @file{po/packages/LINGUAS}."

msgid "New po files for the @code{documentation-manual} component must be"
msgstr "Novos arquivos po para o componente @code{documentation-manual} devem ser"

msgid "registered by adding the file name to @code{DOC_PO_FILES} in @file{po/doc/local.mk}, the generated @file{%D%/guix.xx.texi} manual to @code{info_TEXINFOS} in @file{doc/local.mk} and the generated @file{%D%/guix.xx.texi} and @file{%D%/contributing.xx.texi} to @code{TRANSLATED_INFO} also in @file{doc/local.mk}."
msgstr "registrado adicionando o nome do arquivo em @code{DOC_PO_FILES} em @file{po/doc/local.mk}, o manual gerado em @file{%D%/guix.xx.texi} em @code{info_TEXINFOS} em @file{doc/local.mk} e o gerado em @file{%D%/guix.xx.texi} e @file{%D%/contributing.xx.texi} em @code{TRANSLATED_INFO} também em @file{doc/local.mk}."

msgid "New po files for the @code{documentation-cookbook} component must be"
msgstr "Novos arquivos po para o componente @code{documentation-cookbook} devem ser"

msgid "registered by adding the file name to @code{DOC_COOKBOOK_PO_FILES} in @file{po/doc/local.mk}, the generated @file{%D%/guix-cookbook.xx.texi} manual to @code{info_TEXINFOS} in @file{doc/local.mk} and the generated @file{%D%/guix-cookbook.xx.texi} to @code{TRANSLATED_INFO} also in @file{doc/local.mk}."
msgstr "registrado adicionando o nome do arquivo em @code{DOC_COOKBOOK_PO_FILES} em @file{po/doc/local.mk}, o manual gerado em @file{%D%/guix-cookbook.xx.texi} em @code{info_TEXINFOS} em @file{doc/local.mk} e o gerado em @file{%D%/guix-cookbook.xx.texi} em @code{TRANSLATED_INFO} também em @file{doc/local.mk}."

msgid "New po files for the @code{website} component must be added to the"
msgstr "Novos arquivos po para o componente @code{website} devem ser adicionados ao"

msgid "@code{guix-artwork} repository, in @file{website/po/}.  @file{website/po/LINGUAS} and @file{website/po/ietf-tags.scm} must be updated accordingly (see @file{website/i18n-howto.txt} for more information on the process)."
msgstr "Repositório @code{guix-artwork}, em @file{website/po/}. @file{website/po/LINGUAS} e @file{website/po/ietf-tags.scm} devem ser atualizados adequadamente (veja @file{website/i18n-howto.txt} para mais informações sobre o processo)."

msgid "infrastructure"
msgstr "infraestrutura"

msgid "Since its inception, the Guix project has always valued its autonomy, and that reflects in its infrastructure: our servers run Guix System and exclusively free software, and are administered by volunteers."
msgstr "Desde de o começo, o projeto Guix sempre valorizou sua autonomia, e isso se reflete em sua infraestrutura: nossos servidores rodam Guix System e usam exclusicamente software livre, e são administrados por voluntários."

msgid "Of course this comes at a cost and this is why we need contributions.  Our hope is to make infrastructure-related activity more legible so that maybe you can picture yourself helping in one of these areas."
msgstr "Claro que isso tem um custo, e é por isso que precisamos de contribuições. Nossa esperança é tornar as atividades relacionadas à infraestrutura mais legíveis para que você possa se imaginar ajudando em uma dessas áreas."

msgid "Coding"
msgstr "Código"

msgid "System Administration"
msgstr "Administração do sistema"

msgid "Day-to-Day System Administration"
msgstr "Administração diária do sistema"

msgid "On-Site Intervention"
msgstr "Intervenção no local"

msgid "Hosting"
msgstr "Hospedagem"

msgid "Administrative Tasks"
msgstr "Tarefas administrativas"

msgid "@url{https://git.cbaines.net/guix/bffe, Build Farm Front End}"
msgstr "@url{https://git.cbaines.net/guix/bffe, Front End da Fazenda de compilação}"

msgid "@url{https://codeberg.org/guix/cuirass/, Cuirass}"
msgstr "@url{https://codeberg.org/guix/cuirass/, Cuirass}"

msgid "@url{https://codeberg.org/guix/maintenance/src/branch/master/hydra/goggles.scm, Goggles} (IRC logger)"
msgstr "@url{https://codeberg.org/guix/maintenance/src/branch/master/hydra/goggles.scm, Goggles} (IRC logger)"

msgid "Prerequisites: Familiarity with Guile, HTTP, and databases."
msgstr "Pré-requisitos: familiaridade com o Guile, HTTP, e banco de dados."

msgid "If you wish to get started, check out the README of the project of your choice and get in touch with guix-devel and the primary developer(s) of the tool as per @code{git shortlog -s | sort -k1 -n}."
msgstr "Se você deseja iniciar, dê uma olhada no README do projeto de sua escolha e entre em contato com o guix-devel e os desenvolvedores principais da ferramenta conforme @code{git shortlog -s | sort -k1 -n}."

msgid "Guix System configuration for all our systems is held in this repository:"
msgstr "A configuração do Sistema Guix para todos os nossos sistemas é mantida neste repositório:"

msgid "Without even having SSH access to the machine, you can help by posting patches to improve the configuration (you can test it with @code{guix system vm}).  Here are ways you can help:"
msgstr "Caso não tenha inclusive acesso SSH à máquina, voucê pode ajudar postando patches para melhorar a configuração (pode testar isso com @code{guix system vm}). Alguns caminhos para você poder ajudar:"

msgid "@documentencoding UTF-8"
msgstr ""
"@documentencoding UTF-8\n"
"@documentlanguage pt_BR\n"
"@frenchspacing on"

msgid "GNU Guix Reference Manual"
msgstr "Manual de referência do GNU Guix"

msgid "version.texi"
msgstr "version-pt_BR.texi"

msgid "Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.  A copy of the license is included in the section entitled ``GNU Free Documentation License''."
msgstr "Permissão concedida para copiar, distribuir e/ou modificar este documento sob os termos da Licença de Documentação Livre GNU, Versão 1.3 ou qualquer versão mais recente publicada pela Free Software Foundation; sem Seções Invariantes, Textos de Capa Frontal, e sem Textos de Contracapa. Uma cópia da licença está incluída na seção intitulada ``GNU Free Documentation License''."

msgid "System administration"
msgstr "Administração do sistema"

msgid "Guix: (guix)"
msgstr "Guix.pt_BR: (guix.pt_BR)"

msgid "Manage installed software and system configuration."
msgstr "Gerencie softwares instalados e configuração do sistema."

msgid "guix package: (guix)Invoking guix package"
msgstr "guix package: (guix.pt_BR)Invocando guix package"

msgid "Installing, removing, and upgrading packages."
msgstr "Instalando, removendo e atualizando pacotes."

msgid "guix gc: (guix)Invoking guix gc"
msgstr "guix gc: (guix.pt_BR)Invocando guix gc"

msgid "Reclaiming unused disk space."
msgstr "Recuperando espaço em disco não utilizado."

msgid "guix pull: (guix)Invoking guix pull"
msgstr "guix pull: (guix.pt_BR)Invocando guix pull"

msgid "Update the list of available packages."
msgstr "Atualize a lista de pacotes disponíveis."

msgid "guix system: (guix)Invoking guix system"
msgstr "guix system: (guix.pt_BR)Invocando guix system"

msgid "Manage the operating system configuration."
msgstr "Gerencie a configuração do sistema operacional."

msgid "guix deploy: (guix)Invoking guix deploy"
msgstr "guix deploy: (guix.pt_BR)Invocando guix deploy"

msgid "Manage operating system configurations for remote hosts."
msgstr "Gerenciar configurações do sistema operacional para hosts remotos."

msgid "Software development"
msgstr "Desenvolvimento de software"

msgid "guix shell: (guix)Invoking guix shell"
msgstr "guix shell: (guix.pt_BR)Invocando guix shell"

msgid "guix environment: (guix)Invoking guix environment"
msgstr "guix environment: (guix.pt_BR)Invocando guix environment"

msgid "Building development environments with Guix."
msgstr "Compilando ambientes de desenvolvimento com Guix."

msgid "guix build: (guix)Invoking guix build"
msgstr "guix build: (guix.pt_BR)Invocando guix build"

msgid "Building packages."
msgstr "Compilando pacotes."

msgid "guix pack: (guix)Invoking guix pack"
msgstr "guix pack: (guix.pt_BR)Invocando guix pack"

msgid "Creating binary bundles."
msgstr "Criando embalagens de binários."

msgid "Using the GNU Guix Functional Package Manager"
msgstr "Usando o Gerenciador de Pacotes Funcional GNU Guix"

msgid "The GNU Guix Developers"
msgstr "Desenvolvedores do GNU Guix"

msgid "Edition @value{EDITION} @* @value{UPDATED} @*"
msgstr "Edição @value{EDITION} @* @value{UPDATED} @*"

msgid "Top"
msgstr "Top"

msgid "GNU Guix"
msgstr "GNU Guix"

msgid "This document describes GNU Guix version @value{VERSION}, a functional package management tool written for the GNU system."
msgstr "Esse documento descreve Guix versão @value{VERSION}, uma ferramenta de gerenciamento de pacotes funcional escrita para o sistema GNU."

msgid "This manual is also available in Simplified Chinese (@pxref{Top,,, guix.zh_CN, GNU Guix参考手册}), French (@pxref{Top,,, guix.fr, Manuel de référence de GNU Guix}), German (@pxref{Top,,, guix.de, Referenzhandbuch zu GNU Guix}), Spanish (@pxref{Top,,, guix.es, Manual de referencia de GNU Guix}), Italian (@pxref{Top,,, guix.it, Manuale di riferimento di GNU Guix}), Brazilian Portuguese (@pxref{Top,,, guix.pt_BR, Manual de referência do GNU Guix}), and Russian (@pxref{Top,,, guix.ru, Руководство GNU Guix}).  If you would like to translate it in your native language, consider joining @uref{https://translate.codeberg.org/projects/guix/documentation-manual, Weblate} (@pxref{Translating Guix})."
msgstr "Este manual também está disponível em inglês (@pxref{Top,,, guix, GNU Guix Reference Manual}), chinês simplificado (@pxref{Top ,,, guix.zh_CN, GNU Guix参考手册}), francês (@pxref{Top ,,, guix.fr, Manuel de référence de GNU Guix}), alemão (@pxref{Top,,, guix.de, Referenzhandbuch zu GNU Guix}), espanhol (@pxref{Top,,, guix.es, Manual de referencia de GNU Guix}), italiano (@pxref{Top,,, guix.it, Manuale di riferimento di GNU Guix}) e russo (@pxref{Top,,, guix.ru, Руководство GNU Guix}). Se você quiser traduzi-lo para seu idioma nativo, considere participar do @uref{https://translate.codeberg.org/projects/guix/documentation-manual, Weblate} (@pxref{Translating Guix})."

msgid "Introduction"
msgstr "Introdução"

msgid "What is Guix about?"
msgstr "Sobre o que é o Guix?"

msgid "Installation"
msgstr "Instalação"

msgid "Installing Guix."
msgstr "Instalando o Guix."

msgid "System Installation"
msgstr "Instalação do sistema"

msgid "Installing the whole operating system."
msgstr "Instalando todo o sistema operacional."

msgid "Getting Started"
msgstr "Começando"

msgid "Your first steps."
msgstr "Seus primeiros passos."

msgid "Package Management"
msgstr "Gerenciamento de pacote"

msgid "Package installation, upgrade, etc."
msgstr "Instalação de pacote, atualização, etc."

msgid "Channels"
msgstr "Canais"

msgid "Customizing the package collection."
msgstr "Personalizando a coleção de pacotes."

msgid "Development"
msgstr "Desenvolvimento"

msgid "Guix-aided software development."
msgstr "Desenvolvimento de software auxiliado pelo Guix."

msgid "Programming Interface"
msgstr "Interface de programação"

msgid "Using Guix in Scheme."
msgstr "Usando o Guix no Scheme."

msgid "Utilities"
msgstr "Utilitários"

msgid "Package management commands."
msgstr "Comandos de gerenciamento de pacote."

msgid "Foreign Architectures"
msgstr "Arquiteturas estrangeiras"

msgid "Build for foreign architectures."
msgstr "Construir para arquiteturas estrangeiras."

msgid "System Configuration"
msgstr "Configuração do sistema"

msgid "Configuring the operating system."
msgstr "Configurando o sistema operacional."

msgid "System Troubleshooting Tips"
msgstr "Dicas para solução de problemas do sistema"

msgid "When things don't go as planned."
msgstr "Quando as coisas não saem como planejado."

msgid "Documentation"
msgstr "Documentação"

msgid "Browsing software user manuals."
msgstr "Navegando por manuais do usuário do software."

msgid "Platforms"
msgstr "Plataformas"

msgid "System Images"
msgstr "Imagens do sistema"

msgid "Installing Debugging Files"
msgstr "Instalando arquivos de depuração"

msgid "Feeding the debugger."
msgstr "Alimentando o depurador."

msgid "Using TeX and LaTeX"
msgstr "Usando TeX e LaTeX"

msgid "Security Updates"
msgstr "Atualizações de segurança"

msgid "Deploying security fixes quickly."
msgstr "Implementando correções de segurança rapidamente."

msgid "Bootstrapping"
msgstr "Inicializando"

msgid "GNU/Linux built from scratch."
msgstr "GNU/Linux compilado do zero."

msgid "Porting"
msgstr "Portando"

msgid "Targeting another platform or kernel."
msgstr "Objetivando outra plataforma ou kernel."

msgid "Your help needed!"
msgstr "Sua ajuda é necessária!"

msgid "Acknowledgments"
msgstr "Agradecimentos"

msgid "Thanks!"
msgstr "Obrigado!"

msgid "GNU Free Documentation License"
msgstr "Licença de Documentação Livre GNU"

msgid "The license of this manual."
msgstr "A licença deste manual."

msgid "Concept Index"
msgstr "Índice de conceitos"

msgid "Concepts."
msgstr "Conceitos."

msgid "Programming Index"
msgstr "Índice de programação"

msgid "Data types, functions, and variables."
msgstr "Tipos de dados, funções e variáveis."

msgid "--- The Detailed Node Listing ---"
msgstr "--- A listagem detalhada de nós ---"

msgid "Managing Software the Guix Way"
msgstr "Gerenciando software do jeito do Guix"

msgid "What's special."
msgstr "O que há de especial."

msgid "GNU Distribution"
msgstr "Distribuição GNU"

msgid "The packages and tools."
msgstr "Os pacotes e as ferramentas."

msgid "Binary Installation"
msgstr "Instalação de binários"

msgid "Getting Guix running in no time!"
msgstr "Faça o Guix funcionar rapidamente!"

msgid "Setting Up the Daemon"
msgstr "Configurando o daemon"

msgid "Preparing the build daemon's environment."
msgstr "Preparando o ambiente do daemon de compilação."

msgid "Invoking guix-daemon"
msgstr "Invocando guix-daemon"

msgid "Running the build daemon."
msgstr "Executando o daemon de compilação."

msgid "Application Setup"
msgstr "Configuração de aplicativo"

msgid "Application-specific setup."
msgstr "Configuração específica de aplicativo."

msgid "Upgrading Guix"
msgstr "Atualizando o Guix"

msgid "Upgrading Guix and its build daemon."
msgstr "Atualizando o Guix e seu daemon de compilação."

msgid "Build Environment Setup"
msgstr "Configuração do ambiente de compilação"

msgid "Preparing the isolated build environment."
msgstr "Preparando o ambiente de compilação isolado."

msgid "Daemon Offload Setup"
msgstr "Configuração de descarregamento de daemon"

msgid "Offloading builds to remote machines."
msgstr "Descarregando compilações para máquinas remotas."

msgid "SELinux Support"
msgstr "Suporte a SELinux"

msgid "Using an SELinux policy for the daemon."
msgstr "Usando um política SELinux para o daemon."

msgid "Limitations"
msgstr "Limitações"

msgid "What you can expect."
msgstr "O que você pode esperar."

msgid "Hardware Considerations"
msgstr "Considerações de hardware"

msgid "Supported hardware."
msgstr "Hardware suportado."

msgid "USB Stick and DVD Installation"
msgstr "Instalação em um pendrive e em DVD"

msgid "Preparing the installation medium."
msgstr "Preparando a mídia de instalação."

msgid "Preparing for Installation"
msgstr "Preparando para instalação"

msgid "Networking, partitioning, etc."
msgstr "Rede, particionamento, etc."

msgid "Guided Graphical Installation"
msgstr "Instalação gráfica guiada"

msgid "Easy graphical installation."
msgstr "Instalação gráfica fácil."

msgid "Manual Installation"
msgstr "Instalação manual"

msgid "Manual installation for wizards."
msgstr "Instalação manual para magos."

msgid "After System Installation"
msgstr "Após a instalação do sistema"

msgid "When installation succeeded."
msgstr "Quando a instalação conclui com sucesso."

msgid "Installing Guix in a VM"
msgstr "Instalando Guix em uma VM"

msgid "Guix System playground."
msgstr "Parque de diversões do Guix System."

msgid "Building the Installation Image"
msgstr "Compilando a imagem de instalação"

msgid "How this comes to be."
msgstr "Como isso vem a ser."

msgid "Keyboard Layout and Networking and Partitioning"
msgstr "Disposição de teclado e rede e particionamento"

msgid "Initial setup."
msgstr "Configuração inicial."

msgid "Proceeding with the Installation"
msgstr "Prosseguindo com a instalação"

msgid "Installing."
msgstr "Instalando."

msgid "Features"
msgstr "Recursos"

msgid "How Guix will make your life brighter."
msgstr "Como o Guix vai iluminar a sua vida."

msgid "Invoking guix package"
msgstr "Invocando guix package"

msgid "Package installation, removal, etc."
msgstr "Instalação de pacote, remoção, etc."

msgid "Substitutes"
msgstr "Substitutos"

msgid "Downloading pre-built binaries."
msgstr "Baixando binários pré-compilados."

msgid "Packages with Multiple Outputs"
msgstr "Pacotes com múltiplas saídas"

msgid "Single source package, multiple outputs."
msgstr "Um único pacote de fontes, várias saídas."

msgid "Invoking guix locate"
msgstr "Invocando guix locate"

msgid "Locating packages that provide a file."
msgstr "Localizando pacotes que fornecem um arquivo."

msgid "Invoking guix gc"
msgstr "Invocando guix gc"

msgid "Running the garbage collector."
msgstr "Executando o coletor de lixo."

msgid "Invoking guix pull"
msgstr "Invocando guix pull"

msgid "Fetching the latest Guix and distribution."
msgstr "Obtendo o Guix mais recente e distribuição."

msgid "Invoking guix time-machine"
msgstr "Invocando guix time-machine"

msgid "Running an older revision of Guix."
msgstr "Executando uma revisão mais antiga do Guix."

msgid "Inferiors"
msgstr "Inferiores"

msgid "Interacting with another revision of Guix."
msgstr "Interagindo com outra revisão do Guix."

msgid "Invoking guix describe"
msgstr "Invocando guix describe"

msgid "Display information about your Guix revision."
msgstr "Exibe informações sobre sua revisão do Guix."

msgid "Invoking guix archive"
msgstr "Invocando guix archive"

msgid "Exporting and importing store files."
msgstr "Exportando e importando arquivos do armazém."

msgid "One particular source of substitutes."
msgstr "Uma fonte específica de substitutos."

msgid "Substitute Server Authorization"
msgstr "Autorização de servidor substituto"

msgid "How to enable or disable substitutes."
msgstr "Como habilitar ou desabilitar substitutos."

msgid "Getting Substitutes from Other Servers"
msgstr "Obtendo substitutos de outros servidores"

msgid "Substitute diversity."
msgstr "Diversidade de substitutos."

msgid "Substitute Authentication"
msgstr "Autenticação de substituto"

msgid "How Guix verifies substitutes."
msgstr "Como Guix verifica substitutos."

msgid "Proxy Settings"
msgstr "Configurações de proxy"

msgid "How to get substitutes via proxy."
msgstr "Como obter substitutos via proxy."

msgid "Substitution Failure"
msgstr "Falha na substituição"

msgid "What happens when substitution fails."
msgstr "O que acontece quando a substituição falha."

msgid "On Trusting Binaries"
msgstr "Confiança em binários"

msgid "How can you trust that binary blob?"
msgstr "Como você pode confiar naquele blob binário?"

msgid "Specifying Additional Channels"
msgstr "Especificando canais adicionais"

msgid "Extending the package collection."
msgstr "Ampliando a coleta de pacotes."

msgid "Using a Custom Guix Channel"
msgstr "Usando um canal Guix personalizado"

msgid "Using a customized Guix."
msgstr "Usando um Guix personalizado."

msgid "Replicating Guix"
msgstr "Replicando Guix"

msgid "Running the @emph{exact same} Guix."
msgstr "Executando o @emph{exatamente o mesmo} Guix."

msgid "Channel Authentication"
msgstr "Autenticação de canal"

msgid "How Guix verifies what it fetches."
msgstr "Como o Guix verifica o que busca."

msgid "Channels with Substitutes"
msgstr "Canais com substitutos"

msgid "Using channels with available substitutes."
msgstr "Utilizando canais com substitutos disponíveis."

msgid "Creating a Channel"
msgstr "Criando um canal"

msgid "How to write your custom channel."
msgstr "Como escrever seu canal personalizado."

msgid "Package Modules in a Sub-directory"
msgstr "Módulos de pacote em um subdiretório"

msgid "Specifying the channel's package modules location."
msgstr "Especificando a localização dos módulos do pacote do canal."

msgid "Declaring Channel Dependencies"
msgstr "Declarando dependências de canal"

msgid "How to depend on other channels."
msgstr "Como depender de outros canais."

msgid "Specifying Channel Authorizations"
msgstr "Especificando autorizações de canal"

msgid "Defining channel authors authorizations."
msgstr "Definindo autorizações de autores de canais."

msgid "Primary URL"
msgstr "URL principal"

msgid "Distinguishing mirror to original."
msgstr "Distinguir o espelho do original."

msgid "Writing Channel News"
msgstr "Escrevendo notícias do canal"

msgid "Communicating information to channel's users."
msgstr "Comunicar informações aos usuários do canal."

msgid "Invoking guix shell"
msgstr "Invocando guix shell"

msgid "Invoking guix environment"
msgstr "Invocando guix environment"

msgid "Setting up development environments."
msgstr "Configurando ambientes de desenvolvimento."

msgid "Invoking guix pack"
msgstr "Invocando guix pack"

msgid "Creating software bundles."
msgstr "Criando embalagens de software."

msgid "The GCC toolchain"
msgstr "A cadeia de ferramentas do GCC"

msgid "Working with languages supported by GCC."
msgstr "Trabalhando com idiomas suportados pelo GCC."

msgid "Invoking guix git authenticate"
msgstr "Invocando guix git authenticate"

msgid "Authenticating Git repositories."
msgstr "Autenticando repositórios Git."

msgid "Package Modules"
msgstr "Módulos de pacote"

msgid "Packages from the programmer's viewpoint."
msgstr "Pacotes do ponto de vista do programador."

msgid "Defining Packages"
msgstr "Definindo pacotes"

msgid "Defining new packages."
msgstr "Definindo novos pacotes."

msgid "Defining Package Variants"
msgstr "Definindo variantes de pacote"

msgid "Customizing packages."
msgstr "Personalização de pacotes."

msgid "Writing Manifests"
msgstr "Escrevendo manifestos"

msgid "The bill of materials of your environment."
msgstr "A lista de materiais do seu ambiente."

msgid "Build Systems"
msgstr "Sistemas de compilação"

msgid "Specifying how packages are built."
msgstr "Especificando como pacotes são compilados."

msgid "Build Phases"
msgstr "Fases de construção"

msgid "Phases of the build process of a package."
msgstr "Fases do processo de construção de um pacote."

msgid "Build Utilities"
msgstr "Construir utilitários"

msgid "Helpers for your package definitions and more."
msgstr "Auxiliares para suas definições de pacotes e muito mais."

msgid "Search Paths"
msgstr "Caminhos de pesquisa"

msgid "The Store"
msgstr "O armazém"

msgid "Manipulating the package store."
msgstr "Manipulação do armazém de pacotes."

msgid "Derivations"
msgstr "Derivações"

msgid "Low-level interface to package derivations."
msgstr "Interface de baixo nível para derivações de pacotes."

msgid "The Store Monad"
msgstr "A mônada do armazém"

msgid "Purely functional interface to the store."
msgstr "Interface puramente funcional para o armazém."

msgid "G-Expressions"
msgstr "Expressões-G"

msgid "Manipulating build expressions."
msgstr "Manipulação de expressões de compilação."

msgid "Invoking guix repl"
msgstr "Invocando guix repl"

msgid "Programming Guix in Guile"
msgstr "Programação Guix em Guile"

msgid "Using Guix Interactively"
msgstr "Usando Guix interativamente"

msgid "Fine-grain interaction at the REPL."
msgstr "Interação de granulação fina no REPL."

msgid "package Reference"
msgstr "Referência do package"

msgid "The package data type."
msgstr "O tipo de dados package."

msgid "origin Reference"
msgstr "Referência do origin"

msgid "The origin data type."
msgstr "O tipo de dados origin."

msgid "Invoking guix build"
msgstr "Invocando guix build"

msgid "Building packages from the command line."
msgstr "Compilando pacotes a partir da linha de comando."

msgid "Invoking guix edit"
msgstr "Invocando guix edit"

msgid "Editing package definitions."
msgstr "Editando definições de pacote."

msgid "Invoking guix download"
msgstr "Invocando guix download"

msgid "Downloading a file and printing its hash."
msgstr "Baixando um arquivo e imprimindo seu hash."

msgid "Invoking guix hash"
msgstr "Invocando guix hash"

msgid "Computing the cryptographic hash of a file."
msgstr "Computando a hash criptográfica de um arquivo."

msgid "Invoking guix import"
msgstr "Invocando guix import"

msgid "Importing package definitions."
msgstr "Importando definições de pacote."

msgid "Invoking guix refresh"
msgstr "Invocando guix refresh"

msgid "Updating package definitions."
msgstr "Atualizando definições de pacotes."

msgid "Invoking guix style"
msgstr "Invocando guix style"

msgid "Invoking guix lint"
msgstr "Invocando guix lint"

msgid "Finding errors in package definitions."
msgstr "Encontrando erros nas definições de pacote."

msgid "Invoking guix size"
msgstr "Invocando guix size"

msgid "Profiling disk usage."
msgstr "Perfilando uso de disco."

msgid "Invoking guix graph"
msgstr "Invocando guix graph"

msgid "Visualizing the graph of packages."
msgstr "Visualizando o grafo de pacotes."

msgid "Invoking guix publish"
msgstr "Invocando guix publish"

msgid "Sharing substitutes."
msgstr "Compartilhando substitutos."

msgid "Invoking guix challenge"
msgstr "Invocando guix challenge"

msgid "Challenging substitute servers."
msgstr "Desafiando servidores substitutos."

msgid "Invoking guix copy"
msgstr "Invocando guix copy"

msgid "Copying to and from a remote store."
msgstr "Copiando para e de um armazém remoto."

msgid "Invoking guix container"
msgstr "Invocando guix container"

msgid "Process isolation."
msgstr "Isolação de processo."

msgid "Invoking guix weather"
msgstr "Invocando guix weather"

msgid "Assessing substitute availability."
msgstr "Acessando disponibilidade de substituto."

msgid "Invoking guix processes"
msgstr "Invocando guix processes"

msgid "Listing client processes."
msgstr "Listando processos do cliente."

msgid "Invoking @command{guix build}"
msgstr "Invocando @command{guix build}"

msgid "Common Build Options"
msgstr "Opções de compilação comuns"

msgid "Build options for most commands."
msgstr "Opções de compilação para a maioria dos comandos."

msgid "Package Transformation Options"
msgstr "Opções de transformação de pacote"

msgid "Creating variants of packages."
msgstr "Criando variantes de pacotes."

msgid "Additional Build Options"
msgstr "Opções de compilação adicional"

msgid "Options specific to 'guix build'."
msgstr "Opções específicas para \"guix build\"."

msgid "Debugging Build Failures"
msgstr "Depurando falhas de compilação"

msgid "Real life packaging experience."
msgstr "Experiência de empacotamento na vida real."

msgid "Cross-Compilation"
msgstr "Compilação cruzada"

msgid "Cross-compiling for another architecture."
msgstr "Compilação cruzada para outra arquitetura."

msgid "Native Builds"
msgstr "Construções nativas"

msgid "Getting Started with the System"
msgstr "Começando com o Sistema"

msgid "Using the Configuration System"
msgstr "Usando o sistema de configuração"

msgid "Customizing your GNU system."
msgstr "Personalizando seu sistema GNU."

msgid "operating-system Reference"
msgstr "Referência do operating-system"

msgid "Detail of operating-system declarations."
msgstr "Detalhe das declarações do operating-system."

msgid "File Systems"
msgstr "Sistemas de arquivos"

msgid "Configuring file system mounts."
msgstr "Configurando montagens de sistema de arquivos."

msgid "Mapped Devices"
msgstr "Dispositivos mapeados"

msgid "Block device extra processing."
msgstr "Processamento extra de dispositivo de bloco."

msgid "Swap Space"
msgstr "Espaço de troca (swap)"

msgid "Backing RAM with disk space."
msgstr "Apoiando a RAM com espaço em disco."

msgid "User Accounts"
msgstr "Contas de usuário"

msgid "Specifying user accounts."
msgstr "Especificando contas de usuários."

msgid "Keyboard Layout"
msgstr "Disposição do teclado"

msgid "How the system interprets key strokes."
msgstr "Como o sistema interpreta pressionamento de teclas."

msgid "Locales"
msgstr "Localidades"

msgid "Language and cultural convention settings."
msgstr "Configurações de idioma e de convenção cultural."

msgid "Specifying system services."
msgstr "Especificando serviços de sistema."

msgid "X.509 Certificates"
msgstr "Certificados X.509"

msgid "Authenticating HTTPS servers."
msgstr "Autenticando servidores HTTPS."

msgid "Name Service Switch"
msgstr "Name Service Switch"

msgid "Configuring libc's name service switch."
msgstr "Configurando name service switch do libc."

msgid "Initial RAM Disk"
msgstr "Disco de RAM inicial"

msgid "Linux-Libre bootstrapping."
msgstr "Inicialização do Linux-Libre."

msgid "Bootloader Configuration"
msgstr "Configuração do carregador de inicialização"

msgid "Configuring the boot loader."
msgstr "Configurando o \"bootloader\"."

msgid "Invoking guix system"
msgstr "Invocando guix system"

msgid "Instantiating a system configuration."
msgstr "Inicializando uma configuração de sistema."

msgid "Invoking guix deploy"
msgstr "Invocando guix deploy"

msgid "Deploying a system configuration to a remote host."
msgstr "Implantando uma configuração de sistema em um host remoto."

msgid "Running Guix in a VM"
msgstr "Executando Guix em uma VM"

msgid "How to run Guix System in a virtual machine."
msgstr "Como executar Guix System em uma máquina virtual."

msgid "Defining Services"
msgstr "Definindo serviços"

msgid "Adding new service definitions."
msgstr "Adicionando novas definições de serviço."

msgid "Btrfs file system"
msgstr "Sistema de arquivos Btrfs"

msgid "Base Services"
msgstr "Serviços básicos"

msgid "Essential system services."
msgstr "Serviços essenciais do sistema."

msgid "Scheduled Job Execution"
msgstr "Execução de trabalho agendado"

msgid "The mcron service."
msgstr "O serviço mcron."

msgid "Log Rotation"
msgstr "Rotação de log"

msgid "Setting up network interfaces."
msgstr "Configurando interfaces de rede."

msgid "Networking Services"
msgstr "Serviços de Rede"

msgid "Unattended Upgrades"
msgstr "Atualizações sem supervisão"

msgid "Automated system upgrades."
msgstr "Atualizações automatizadas do sistema."

msgid "X Window"
msgstr "X Window"

msgid "Graphical display."
msgstr "Exibição gráfica."

msgid "Printing Services"
msgstr "Serviços de impressão"

msgid "Local and remote printer support."
msgstr "Suporte a impressora local e remota."

msgid "Desktop Services"
msgstr "Serviços de desktop"

msgid "D-Bus and desktop services."
msgstr "Serviços de D-Bus e desktop."

msgid "Sound Services"
msgstr "Serviços de som"

msgid "ALSA and Pulseaudio services."
msgstr "Serviços ALSA e Pulseaudio."

msgid "Tools to search for files."
msgstr "Ferramentas para procurar arquivos."

msgid "Database Services"
msgstr "Serviços de bancos de dados"

msgid "SQL databases, key-value stores, etc."
msgstr "Banco de dados SQL, armazenamentos de valor chave, etc."

msgid "Mail Services"
msgstr "Serviços de correio"

msgid "IMAP, POP3, SMTP, and all that."
msgstr "IMAP, POP3, SMTP e tudo isso."

msgid "Messaging Services"
msgstr "Serviços de mensageria"

msgid "Messaging services."
msgstr "Serviços de mensageria."

msgid "Telephony Services"
msgstr "Serviços de telefonia"

msgid "Telephony services."
msgstr "Serviços de telefonia."

msgid "File-Sharing Services"
msgstr "Serviços de compartilhamento de arquivos"

msgid "File-sharing services."
msgstr "Serviços de compartilhamento de arquivos."

msgid "Monitoring Services"
msgstr "Serviços de monitoramento"

msgid "Monitoring services."
msgstr "Serviços de monitoramento."

msgid "Kerberos Services"
msgstr "Serviços Kerberos"

msgid "Kerberos services."
msgstr "Serviços Kerberos."

msgid "LDAP Services"
msgstr "Serviços LDAP"

msgid "LDAP services."
msgstr "Serviços LDAP."

msgid "Web Services"
msgstr "Serviços web"

msgid "Web servers."
msgstr "Servidores Web."

msgid "Certificate Services"
msgstr "Serviços de certificado"

msgid "TLS certificates via Let's Encrypt."
msgstr "Certificados TLS via Let's Encrypt."

msgid "DNS Services"
msgstr "Serviços DNS"

msgid "DNS daemons."
msgstr "Deamons DNS."

msgid "VPN Services"
msgstr "Serviços VPN"

msgid "VPN daemons."
msgstr "Deamons VPN."

msgid "Network File System"
msgstr "Sistema de arquivos de rede"

msgid "NFS related services."
msgstr "Serviços relacionados a NFS."

msgid "Samba services."
msgstr "Serviços Samba."

msgid "Continuous Integration"
msgstr "Integração Contínua"

msgid "Cuirass and Laminar services."
msgstr "Os serviços Cuirass e Laminar."

msgid "Power Management Services"
msgstr "Serviços de gerenciamento de energia"

msgid "Audio Services"
msgstr "Serviços de áudio"

msgid "The MPD."
msgstr "O MPD."

msgid "Virtualization Services"
msgstr "Serviços de virtualização"

msgid "Virtualization services."
msgstr "Serviços de virtualização."

msgid "Version Control Services"
msgstr "Serviços de controlando versão"

msgid "Game Services"
msgstr "Serviços de jogos"

msgid "Game servers."
msgstr "Servidores de jogos."

msgid "PAM Mount Service"
msgstr "Serviço de montagem PAM"

msgid "Service to mount volumes when logging in."
msgstr "Serviço para montar volumes ao efetuar login."

msgid "Guix Services"
msgstr "Serviços Guix"

msgid "Services relating specifically to Guix."
msgstr "Serviços relacionados especificamente ao Guix."

msgid "Linux Services"
msgstr "Serviços Linux"

msgid "Services tied to the Linux kernel."
msgstr "Serviços vinculados ao kernel Linux."

msgid "Hurd Services"
msgstr "Serviços Hurd"

msgid "Services specific for a Hurd System."
msgstr "Serviços específicos para um Sistema Hurd."

msgid "Miscellaneous Services"
msgstr "Serviços diversos"

msgid "Other services."
msgstr "Outros serviços."

msgid "Service Composition"
msgstr "Composição de serviço"

msgid "The model for composing services."
msgstr "O modelo para serviços de composição."

msgid "Service Types and Services"
msgstr "Tipos de Service e Serviços"

msgid "Types and services."
msgstr "Tipos e serviços."

msgid "Service Reference"
msgstr "Referência de Service"

msgid "API reference."
msgstr "Referência de API."

msgid "Shepherd Services"
msgstr "Serviços de Shepherd"

msgid "A particular type of service."
msgstr "Um tipo em particular de serviço."

msgid "Chrooting into an existing system"
msgstr "Acessando um sistema existente via chroot"

msgid "Declaring the Home Environment"
msgstr "Declarando o ambiente pessoal"

msgid "Customizing your Home."
msgstr "Personalizando seu ambiente pessoal."

msgid "Configuring the Shell"
msgstr "Configurando o \"Shell\""

msgid "Enabling home environment."
msgstr "Habilitando o ambiente pessoal."

msgid "Home Services"
msgstr "Serviços pessoais"

msgid "Specifying home services."
msgstr "Especificando serviços pessoais."

msgid "Invoking guix home"
msgstr "Invocando guix home"

msgid "Instantiating a home configuration."
msgstr "Inicializando uma configuração pessoal."

msgid "Essential Home Services"
msgstr "Serviços essenciais pessoais"

msgid "Environment variables, packages, on-* scripts."
msgstr "Variáveis de ambiente, pacotes, scripts on-*."

msgid "POSIX shells, Bash, Zsh."
msgstr "POSIX shells, Bash, Zsh."

msgid "Scheduled User's Job Execution."
msgstr "Execução de trabalho do Usuário agendado."

msgid "SSH: Secure Shell"
msgstr "SSH: Secure Shell"

msgid "Setting up the secure shell client."
msgstr "Configurando o cliente de shell seguro."

msgid "GPG: GNU Privacy Guard"
msgstr "GPG: GNU Privacy Guard"

msgid "Setting up GPG and related tools."
msgstr "Configurando GPG e ferramentas relacionadas."

msgid "Services for graphical environments."
msgstr "Serviços para ambientes gráficos."

msgid "Dealing with audio."
msgstr "Lidando com áudio."

msgid "Sway: Sway window manager"
msgstr "Sway: Gerenciador de janelas Sway"

msgid "platform Reference"
msgstr "Referência do platform"

msgid "Creating System Images"
msgstr "Criando imagens do sistema"

msgid "Instantiate an Image"
msgstr "Instanciar uma imagem"

msgid "How to instantiate an image record."
msgstr "Como instanciar um registro de imagem."

msgid "Image Modules"
msgstr "Módulos de imagem"

msgid "Definition of image modules."
msgstr "Definição de módulos de imagem."

msgid "partition Reference"
msgstr "Referência do partition"

msgid "Separate Debug Info"
msgstr "Informações de depuração separadas"

msgid "Installing 'debug' outputs."
msgstr "Instalando saídas de 'depuração'."

msgid "Rebuilding Debug Info"
msgstr "Reconstruindo informações de depuração"

msgid "Building missing debug info."
msgstr "Informações de depuração ausentes no edifício."

msgid "Full-Source Bootstrap"
msgstr "Bootstrap de código fonte completo"

msgid "A Bootstrap worthy of GNU."
msgstr "Um Bootstrap digno do GNU."

msgid "Preparing to Use the Bootstrap Binaries"
msgstr "Preparando para usar os binários do Bootstrap"

msgid "Building that what matters most."
msgstr "Construindo o que mais importa."

msgid "purpose"
msgstr "propósito"

msgid "GNU Guix@footnote{``Guix'' is pronounced like ``geeks'', or ``ɡiːks'' using the international phonetic alphabet (IPA).} is a package management tool for and distribution of the GNU system.  Guix makes it easy for unprivileged users to install, upgrade, or remove software packages, to roll back to a previous package set, to build packages from source, and generally assists with the creation and maintenance of software environments."
msgstr "GNU Guix@footnote{``Guix'' é pronunciado como ``geeks'', ou ``ɡiːks'' usando o alfabeto fonético internacional (IPA).} é uma ferramenta de gerenciamento de pacotes e distribuição do sistema GNU. O Guix facilita a instalação, a atualização ou a remoção de pacotes de software, a reversão para um conjunto de pacotes anterior, a compilação de pacotes a partir do código-fonte e geralmente ajuda na criação e manutenção de ambientes de software."

msgid "Guix System"
msgstr "Sistema Guix"

msgid "GuixSD, now Guix System"
msgstr "GuixSD, agora Guix System"

msgid "Guix System Distribution, now Guix System"
msgstr "Guix System Distribution, agora Guix System"

msgid "You can install GNU@tie{}Guix on top of an existing GNU/Linux system where it complements the available tools without interference (@pxref{Installation}), or you can use it as a standalone operating system distribution, @dfn{Guix@tie{}System}@footnote{We used to refer to Guix System as ``Guix System Distribution'' or ``GuixSD''.  We now consider it makes more sense to group everything under the ``Guix'' banner since, after all, Guix System is readily available through the @command{guix system} command, even if you're using a different distro underneath!}.  @xref{GNU Distribution}."
msgstr "Você pode instalar o GNU@tie{}Guix sobre um sistema GNU/Linux existente, onde ele complementa as ferramentas disponíveis sem interferência (@pxref{Installation}) ou você pode usá-lo como uma distribuição de sistema operacional independente, @dfn{Guix@tie{}System}@footnote{Costumávamos nos referir ao Guix System como ``Guix System Distribution'' ou ``GuixSD''. Agora consideramos que faz mais sentido agrupar tudo sob o banner ``Guix'', pois, afinal, o Guix System está prontamente disponível através do comando @command{guix system}, mesmo se você estiver usando uma distribuição diferente por baixo!}. @xref{GNU Distribution}."

msgid "user interfaces"
msgstr "interfaces de usuário"

msgid "Guix provides a command-line package management interface (@pxref{Package Management}), tools to help with software development (@pxref{Development}), command-line utilities for more advanced usage (@pxref{Utilities}), as well as Scheme programming interfaces (@pxref{Programming Interface})."
msgstr "O Guix fornece uma interface de gerenciamento de pacotes de linha de comando (@pxref{Package Management}), ferramentas para ajudar no desenvolvimento de software (@pxref{Development}), utilitários de linha de comando para uso mais avançado (@pxref{Utilities}), bem como interfaces de programação Scheme (@pxref{Programming Interface})."

msgid "build daemon"
msgstr "build daemon"

msgid "Its @dfn{build daemon} is responsible for building packages on behalf of users (@pxref{Setting Up the Daemon}) and for downloading pre-built binaries from authorized sources (@pxref{Substitutes})."
msgstr "O @dfn{build daemon} é responsável por compilar pacotes em nome dos usuários (@pxref{Setting Up the Daemon}) e por baixar binários pré-compilados de fontes autorizados (@pxref{Substitutes})."

msgid "extensibility of the distribution"
msgstr "extensibilidade da distribuição"

msgid "customization, of packages"
msgstr "personalização, de pacotes"

msgid "Guix includes package definitions for many GNU and non-GNU packages, all of which @uref{https://www.gnu.org/philosophy/free-sw.html, respect the user's computing freedom}.  It is @emph{extensible}: users can write their own package definitions (@pxref{Defining Packages}) and make them available as independent package modules (@pxref{Package Modules}).  It is also @emph{customizable}: users can @emph{derive} specialized package definitions from existing ones, including from the command line (@pxref{Package Transformation Options})."
msgstr "Guix inclui definições de pacotes para muitos pacotes GNU e não-GNU, todos os quais @uref{https://www.gnu.org/philosophy/free-sw.html, respeitam a liberdade de computação do usuário}. É @emph{extensível}: os usuários podem escrever suas próprias definições de pacotes (@pxref{Defining Packages}) e disponibilizá-los como módulos de pacotes independentes (@pxref{Package Modules}). Também é @emph{personalizável}: os usuários podem @emph{derivar} definições de pacotes especializados das existentes, incluindo da linha de comando (@pxref{Package Transformation Options})."

msgid "functional package management"
msgstr "gerenciamento de pacotes funcional"

msgid "isolation"
msgstr "isolação"

msgid "Under the hood, Guix implements the @dfn{functional package management} discipline pioneered by Nix (@pxref{Acknowledgments}).  In Guix, the package build and installation process is seen as a @emph{function}, in the mathematical sense.  That function takes inputs, such as build scripts, a compiler, and libraries, and returns an installed package.  As a pure function, its result depends solely on its inputs---for instance, it cannot refer to software or scripts that were not explicitly passed as inputs.  A build function always produces the same result when passed a given set of inputs.  It cannot alter the environment of the running system in any way; for instance, it cannot create, modify, or delete files outside of its build and installation directories.  This is achieved by running build processes in isolated environments (or @dfn{containers}), where only their explicit inputs are visible."
msgstr "Nos bastidores, a Guix implementa a disciplina @dfn{gerenciamento de pacotes funcional} pioneira da Nix (@pxref{Acknowledgments}). No Guix, o processo de compilação e instalação de pacotes é visto como uma @emph{função}, no sentido matemático. Essa função recebe entradas, como scripts de compilação, um compilador e bibliotecas, e retorna um pacote instalado. Como uma função pura, seu resultado depende apenas de suas entradas – por exemplo, não pode fazer referência a um software ou scripts que não foram explicitamente passados como entradas. Uma função de compilação sempre produz o mesmo resultado ao passar por um determinado conjunto de entradas. Não pode alterar o ambiente do sistema em execução de qualquer forma; por exemplo, ele não pode criar, modificar ou excluir arquivos fora de seus diretórios de compilação e instalação. Isto é conseguido através da execução de processos de compilação em ambientes isolados (ou @dfn{containers}), onde somente suas entradas explícitas são visíveis."

msgid "store"
msgstr "store"

msgid "The result of package build functions is @dfn{cached} in the file system, in a special directory called @dfn{the store} (@pxref{The Store}).  Each package is installed in a directory of its own in the store---by default under @file{/gnu/store}.  The directory name contains a hash of all the inputs used to build that package; thus, changing an input yields a different directory name."
msgstr "O resultado das funções de compilação do pacote é mantido (@dfn{cached}) no sistema de arquivos, em um diretório especial chamado @dfn{armazém} (@pxref{The Store}). Cada pacote é instalado em um diretório próprio no armazém – por padrão, em @file{/gnu/store}. O nome do diretório contém um hash de todas as entradas usadas para compilar esse pacote; Assim, a alteração uma entrada gera um nome de diretório diferente."

msgid "This approach is the foundation for the salient features of Guix: support for transactional package upgrade and rollback, per-user installation, and garbage collection of packages (@pxref{Features})."
msgstr "Essa abordagem é a fundação para os principais recursos do Guix: suporte para atualização transacional de pacotes e reversão, instalação por usuário e coleta de lixo de pacotes (@pxref{Features})."

msgid "Guix comes with a distribution of the GNU system consisting entirely of free software@footnote{The term ``free'' here refers to the @url{https://www.gnu.org/philosophy/free-sw.html,freedom provided to users of that software}.}.  The distribution can be installed on its own (@pxref{System Installation}), but it is also possible to install Guix as a package manager on top of an installed GNU/Linux system (@pxref{Installation}).  When we need to distinguish between the two, we refer to the standalone distribution as Guix@tie{}System."
msgstr "O Guix vem com uma distribuição do sistema GNU que consiste inteiramente de software livre@footnote{O termo ``free'' em ``free software`` se refere à @url{https://www.gnu.org/philosophy/free-sw.html,liberdade fornecida aos usuários desse software}. A ambiguidade no termo em inglês não ocorre na tradução para português ``livre``.}. A distribuição pode ser instalada por conta própria (@pxref{System Installation}), mas também é possível instalar o Guix como um gerenciador de pacotes em cima de um sistema GNU/Linux instalado (@pxref{Installation}). Quando precisamos distinguir entre os dois, nos referimos à distribuição independente como Guix@tie{}System."

msgid "The distribution provides core GNU packages such as GNU libc, GCC, and Binutils, as well as many GNU and non-GNU applications.  The complete list of available packages can be browsed @url{https://www.gnu.org/software/guix/packages,on-line} or by running @command{guix package} (@pxref{Invoking guix package}):"
msgstr "A distribuição fornece pacotes GNU principais, como GNU libc, GCC e Binutils, além de muitos aplicativos GNU e não GNU. A lista completa de pacotes disponíveis pode ser acessada @url{https://www.gnu.org/software/guix/packages,online} ou executando @command{guix package} (@pxref{Invoking guix package}):"

msgid "guix package --list-available\n"
msgstr "guix package --list-available\n"

msgid "Our goal is to provide a practical 100% free software distribution of Linux-based and other variants of GNU, with a focus on the promotion and tight integration of GNU components, and an emphasis on programs and tools that help users exert that freedom."
msgstr "Nosso objetivo é fornecer uma distribuição prática e 100% de software livre, baseada em Linux e outras variantes do GNU, com foco na promoção e forte integração de componentes do GNU e ênfase em programas e ferramentas que ajudam os usuários a exercer essa liberdade."

msgid "Packages are currently available on the following platforms:"
msgstr "Os pacotes estão atualmente disponíveis nas seguintes plataformas:"

msgid "x86_64-linux"
msgstr "x86_64-linux"

msgid "Intel/AMD @code{x86_64} architecture, Linux-Libre kernel."
msgstr "Arquitetura Intel/AMD @code{x86_64}, kernel Linux-Libre."

msgid "i686-linux"
msgstr "i686-linux"

msgid "Intel 32-bit architecture (IA32), Linux-Libre kernel."
msgstr "Arquitetura Intel de 32 bits (IA32), kernel Linux-Libre."

msgid "armhf-linux"
msgstr "armhf-linux"

msgid "ARMv7-A architecture with hard float, Thumb-2 and NEON, using the EABI hard-float application binary interface (ABI), and Linux-Libre kernel."
msgstr "Arquitetura ARMv7-A com hard float, Thumb-2 e NEON, usando a interface binária de aplicativos EABI hard-float (ABI) e o kernel Linux-Libre."

msgid "aarch64-linux"
msgstr "aarch64-linux"

msgid "little-endian 64-bit ARMv8-A processors, Linux-Libre kernel."
msgstr "Processadores ARMv8-A little-endian de 64 bits, kernel Linux-Libre."

msgid "i586-gnu"
msgstr "i586-gnu"

msgid "@uref{https://hurd.gnu.org, GNU/Hurd} on the Intel 32-bit architecture (IA32)."
msgstr "@uref{https://hurd.gnu.org, GNU/Hurd} sobre a arquitetura Intel de 32 bits (IA32)."

msgid "This configuration is experimental and under development.  The easiest way for you to give it a try is by setting up an instance of @code{hurd-vm-service-type} on your GNU/Linux machine (@pxref{transparent-emulation-qemu, @code{hurd-vm-service-type}}).  @xref{Contributing}, on how to help!"
msgstr "Esta configuração é experimental e está em desenvolvimento. A maneira mais fácil de você tentar é configurando uma instância de @code{hurd-vm-service-type} na sua máquina GNU/Linux (@pxref{transparent-emulation-qemu, @code{hurd-vm-service-type}}). @xref{Contributing}, sobre como ajudar!"

msgid "mips64el-linux (unsupported)"
msgstr "mips64el-linux (sem suporte)"

msgid "little-endian 64-bit MIPS processors, specifically the Loongson series, n32 ABI, and Linux-Libre kernel.  This configuration is no longer fully supported; in particular, there is no ongoing work to ensure that this architecture still works.  Should someone decide they wish to revive this architecture then the code is still available."
msgstr "processadores little-endian MIPS de 64 bits, especificamente a série Loongson, n32 ABI e kernel Linux-Libre. Esta configuração não é mais totalmente suportada; em particular, não há trabalho em andamento para garantir que esta arquitetura ainda funcione. Caso alguém decida que deseja reviver esta arquitetura, o código ainda estará disponível."

msgid "powerpc-linux (unsupported)"
msgstr "powerpc-linux (sem suporte)"

msgid "big-endian 32-bit PowerPC processors, specifically the PowerPC G4 with AltiVec support, and Linux-Libre kernel.  This configuration is not fully supported and there is no ongoing work to ensure this architecture works."
msgstr "processadores PowerPC big-endian de 32 bits, especificamente o PowerPC G4 com suporte AltiVec e kernel Linux-Libre. Esta configuração não é totalmente suportada e não há trabalho em andamento para garantir que esta arquitetura funcione."

msgid "powerpc64le-linux"
msgstr "powerpc64le-linux"

msgid "little-endian 64-bit Power ISA processors, Linux-Libre kernel.  This includes POWER9 systems such as the @uref{https://www.fsf.org/news/talos-ii-mainboard-and-talos-ii-lite-mainboard-now-fsf-certified-to-respect-your-freedom, RYF Talos II mainboard}. This platform is available as a \"technology preview\": although it is supported, substitutes are not yet available from the build farm (@pxref{Substitutes}), and some packages may fail to build (@pxref{Tracking Bugs and Changes}).  That said, the Guix community is actively working on improving this support, and now is a great time to try it and get involved!"
msgstr "processadores little-endian 64 bits Power ISA, kernel Linux-Libre. Isso inclui sistemas POWER9 como o @uref{https://www.fsf.org/news/talos-ii-mainboard-and-talos-ii-lite-mainboard-now-fsf-certified-to-respect-your-freedom, placa-mãe RYF Talos II}. Esta plataforma está disponível como uma \"prévia de tecnologia\": embora seja suportada, substitutos ainda não estão disponíveis na fazenda de construção (@pxref{Substitutes}), e alguns pacotes podem falhar na construção (@pxref{Tracking Bugs and Changes}). Dito isso, a comunidade Guix está trabalhando ativamente para melhorar esse suporte, e agora é um ótimo momento para experimentá-lo e se envolver!"

msgid "little-endian 64-bit RISC-V processors, specifically RV64GC, and Linux-Libre kernel. This platform is available as a \"technology preview\": although it is supported, substitutes are not yet available from the build farm (@pxref{Substitutes}), and some packages may fail to build (@pxref{Tracking Bugs and Changes}).  That said, the Guix community is actively working on improving this support, and now is a great time to try it and get involved!"
msgstr "processadores little-endian RISC-V de 64 bits, especificamente RV64GC, e kernel Linux-Libre. Esta plataforma está disponível como uma \"prévia de tecnologia\": embora seja suportada, substitutos ainda não estão disponíveis na build farm (@pxref{Substitutes}), e alguns pacotes podem falhar na compilação (@pxref{Tracking Bugs and Changes}). Dito isto, a comunidade Guix está trabalhando ativamente para melhorar este suporte, e agora é um ótimo momento para experimentá-lo e se envolver!"

msgid "With Guix@tie{}System, you @emph{declare} all aspects of the operating system configuration and Guix takes care of instantiating the configuration in a transactional, reproducible, and stateless fashion (@pxref{System Configuration}).  Guix System uses the Linux-libre kernel, the Shepherd initialization system (@pxref{Introduction,,, shepherd, The GNU Shepherd Manual}), the well-known GNU utilities and tool chain, as well as the graphical environment or system services of your choice."
msgstr "Com o Guix@tie{}System, você @emph{declara} todos os aspectos da configuração do sistema operacional, e o Guix cuida de instanciar a configuração de maneira transacional, reproduzível e sem estado (@pxref{System Configuration}). O Guix System usa o kernel Linux-libre, o sistema de inicialização Shepherd (@pxref{Introduction ,,, shepherd, The GNU Shepherd Manual}), os conhecidos utilitários do GNU e cadeia de ferramentas, bem como o ambiente gráfico ou os serviços de sistema do sua escolha."

msgid "For information on porting to other architectures or kernels, @pxref{Porting}."
msgstr "Para obter informações sobre como portar para outras arquiteturas ou kernels, @pxref{Porting}."

msgid "Building this distribution is a cooperative effort, and you are invited to join! @xref{Contributing}, for information about how you can help."
msgstr "A construção desta distribuição é um esforço cooperativo e você está convidado a participar! @xref{Contributing}, para obter informações sobre como você pode ajudar."

msgid "installing Guix"
msgstr "instalando Guix"

msgid "foreign distro"
msgstr "distro alheia"

msgid "You can install the package management tool Guix on top of an existing GNU/Linux or GNU/Hurd system@footnote{Hurd support is currently limited.}, referred to as a @dfn{foreign distro}.  If, instead, you want to install the complete, standalone GNU system distribution, @dfn{Guix@tie{}System}, @pxref{System Installation}.  This section is concerned only with the installation of Guix on a foreign distro."
msgstr "Você pode instalar a ferramenta de gerenciamento de pacotes Guix sobre um sistema GNU/Linux ou GNU/Hurd existente@footnote{O suporte ao Hurd é atualmente limitado.}, conhecido como @dfn{distro estrangeiro}. Se, em vez disso, você quiser instalar a distribuição completa e autônoma do sistema GNU, @dfn{Guix@tie{}System}, @pxref{System Installation}. Esta seção se preocupa apenas com a instalação do Guix em uma distro estrangeira."

msgid "This section only applies to systems without Guix.  Following it for existing Guix installations will overwrite important system files."
msgstr "Esta seção se aplica somente a sistemas sem Guix. Segui-la para instalações Guix existentes sobrescreverá arquivos importantes do sistema."

msgid "directories related to foreign distro"
msgstr "diretórios relacionados à distro alheia"

msgid "When installed on a foreign distro, GNU@tie{}Guix complements the available tools without interference.  Its data lives exclusively in two directories, usually @file{/gnu/store} and @file{/var/guix}; other files on your system, such as @file{/etc}, are left untouched."
msgstr "Quando instalado sobre uma distro alheia. GNU@tie{}Guix complementa as ferramentas disponíveis sem interferência. Seus dados residem exclusivamente em dois diretórios, geralmente @file{/gnu/store} e @file{/var/guix}; outros arquivos no seu sistema, como @file{/etc}, são deixados intactos."

msgid "Once installed, Guix can be updated by running @command{guix pull} (@pxref{Invoking guix pull})."
msgstr "Uma vez instalado, o Guix pode ser atualizado executando @command{guix pull} (@pxref{Invoking guix pull})."

msgid "installing Guix from binaries"
msgstr "instalando Guix de binários"

msgid "installer script"
msgstr "script de instalação"

msgid "When you're done installing Guix, @pxref{Application Setup} for extra configuration you might need, and @ref{Getting Started} for your first steps!"
msgstr "Quando terminar de instalar o Guix, @pxref{Application Setup} para configurações extras que você pode precisar e @ref{Getting Started} para seus primeiros passos!"

msgid "Setting up the build daemon (@pxref{Setting Up the Daemon})."
msgstr "Configurando o daemon (@pxref{Setting Up the Daemon})."

msgid "Making the @command{guix} command available to non-root users."
msgstr "Disponibilizando o comando @command{guix} para usuários não root."

msgid "By default, @file{guix-install.sh} will configure Guix to download pre-built package binaries, called @dfn{substitutes} (@pxref{Substitutes}), from the project's build farms.  If you choose not to permit this, Guix will build @emph{everything} from source, making each installation and upgrade very expensive.  @xref{On Trusting Binaries} for a discussion of why you may want to build packages from source."
msgstr "Por padrão, @file{guix-install.sh} configurará o Guix para baixar binários de pacotes pré-construídos, chamados @dfn{substitutes} (@pxref{Substitutes}), das fazendas de construção do projeto. Se você escolher não permitir isso, o Guix construirá @emph{tudo} a partir da fonte, tornando cada instalação e atualização muito cara. @xref{On Trusting Binaries} para uma discussão sobre por que você pode querer construir pacotes a partir da fonte."

msgid "substitutes, authorization thereof"
msgstr "substitutos, autenticação dela"

msgid "To use substitutes from @code{@value{SUBSTITUTE-SERVER-1}}, @code{@value{SUBSTITUTE-SERVER-2}} or a mirror, you must authorize them.  For example,"
msgstr "Para usar substitutos de @code{@value{SUBSTITUTE-SERVER-1}}, @code{@value{SUBSTITUTE-SERVER-2}} ou um espelho, você deve autorizá-los. Por exemplo,"

msgid "The binary installation tarball can be (re)produced and verified simply by running the following command in the Guix source tree:"
msgstr "O tarball da instalação binária pode ser (re)produzido e verificado simplesmente executando o seguinte comando na árvore de código-fonte do Guix:"

msgid "make guix-binary.@var{system}.tar.xz\n"
msgstr "make guix-binary.@var{sistema}.tar.xz\n"

msgid "...@: which, in turn, runs:"
msgstr "...@: que, por sua vez, executa:"

msgid ""
"guix pack -s @var{system} --localstatedir \\\n"
"  --profile-name=current-guix guix\n"
msgstr ""
"guix pack -s @var{sistema} --localstatedir \\\n"
"  --profile-name=current-guix guix\n"

msgid "@xref{Invoking guix pack}, for more info on this handy tool."
msgstr "@xref{Invoking guix pack}, para mais informações sobre essa ferramenta útil."

msgid "Should you eventually want to uninstall Guix, run the same script with the @option{--uninstall} flag:"
msgstr "Caso você queira desinstalar o Guix, execute o mesmo script com o sinalizador @option{--uninstall}:"

msgid "With @option{--uninstall}, the script irreversibly deletes all the Guix files, configuration, and services."
msgstr "Com @option{--uninstall}, o script exclui irreversivelmente todos os arquivos Guix, configuração e serviços."

msgid "Some GNU/Linux distributions, such as openSUSE, Alpine and NixOS provide Guix through their own package managers.  The version of Guix may be older than @value{VERSION} but you can update it afterwards by running @command{guix pull}."
msgstr "Algumas distribuições GNU/Linux, como openSUSE, Alpine e NixOS fornecem Guix por meio de seus próprios gerenciadores de pacotes. A versão do Guix pode ser mais antiga que @value{VERSION}, mas você pode atualizá-la depois executando @command{guix pull}."

msgid "We advise system administrators who install Guix, both from the installation script or @i{via} the native package manager of their foreign distribution, to also regularly read and follow security notices, as shown by @command{guix pull}."
msgstr "Aconselhamos os administradores de sistema que instalam o Guix, tanto a partir do script de instalação quanto por meio do gerenciador de pacotes nativo de sua distribuição estrangeira, a também ler e seguir regularmente os avisos de segurança, conforme mostrado pelo @command{guix pull}."

msgid "daemon"
msgstr "daemon"

msgid "During installation, the @dfn{build daemon} that must be running to use Guix has already been set up and you can run @command{guix} commands in your terminal program, @pxref{Getting Started}:"
msgstr "Durante a instalação, o @dfn{build daemon} que deve estar em execução para usar o Guix já foi configurado e você pode executar comandos @command{guix} no seu programa de terminal, @pxref{Getting Started}:"

msgid "If this runs through without error, feel free to skip this section.  You should continue with the following section, @ref{Application Setup}."
msgstr "Se isso ocorrer sem erros, sinta-se à vontade para pular esta seção. Você deve continuar com a seção seguinte, @ref{Application Setup}."

msgid "However, now would be a good time to replace outdated daemon versions, tweak it, perform builds on other machines (@pxref{Daemon Offload Setup}), or start it manually in special environments like ``chroots'' (@pxref{Chrooting into an existing system}) or WSL (not needed for WSL images created with Guix, @pxref{System Images, @code{wsl2-image-type}}).  If you want to know more or optimize your system, this section is worth reading."
msgstr "No entanto, agora seria um bom momento para substituir versões desatualizadas do daemon, ajustá-lo, executar compilações em outras máquinas (@pxref{Daemon Offload Setup}) ou iniciá-lo manualmente em ambientes especiais como ``chroots'' (@pxref{Chrooting into an existing system}) ou WSL (não necessário para imagens WSL criadas com Guix, @pxref{System Images, @code{wsl2-image-type}}). Se você quiser saber mais ou otimizar seu sistema, vale a pena ler esta seção."

msgid "Operations such as building a package or running the garbage collector are all performed by a specialized process, the build daemon, on behalf of clients.  Only the daemon may access the store and its associated database.  Thus, any operation that manipulates the store goes through the daemon.  For instance, command-line tools such as @command{guix package} and @command{guix build} communicate with the daemon (@i{via} remote procedure calls) to instruct it what to do."
msgstr "Operações como compilar um pacote ou executar o coletor de lixo são todas executadas por um processo especializado, o build daemon, em nome dos clientes. Apenas o daemon pode acessar o armazém e seu banco de dados associado. Assim, qualquer operação que manipule o armazém passa pelo daemon. Por exemplo, ferramentas de linha de comando como @command{guix package} e @command{guix build} se comunicam com o daemon (@i{via} chamadas de procedimento remoto) para instruir o que fazer."

msgid "The following sections explain how to prepare the build daemon's environment.  @xref{Substitutes} for how to allow the daemon to download pre-built binaries."
msgstr "As seções a seguir explicam como preparar o ambiente do daemon de compilação. @xref{Substitutes} para informações sobre como permitir que o daemon baixe binários pré-compilados."

msgid "build environment"
msgstr "ambiente de compilação"

msgid "In a standard multi-user setup, Guix and its daemon---the @command{guix-daemon} program---are installed by the system administrator.  Unprivileged users may use Guix tools to build packages or otherwise access the store, and the daemon will do it on their behalf, ensuring that the store is kept in a consistent state, and allowing built packages to be shared among users."
msgstr "Em uma configuração multiusuário padrão, o Guix e seu daemon – o programa @command{guix-daemon} – são instalados pelo administrador do sistema. Usuários desprivilegiados podem usar ferramentas Guix para criar pacotes ou acessar o armazém, e o daemon fará isso em seu nome, garantindo que o armazém seja mantido em um estado consistente e permitindo que pacotes construídos sejam compartilhados entre os usuários."

msgid "Daemon Running as Root"
msgstr "Daemon se executando como root"

msgid "build users"
msgstr "usuários de compilação"

msgid "When @command{guix-daemon} runs as @code{root}, you may not want package build processes themselves to run as @code{root} too, for obvious security reasons.  To avoid that, a special pool of @dfn{build users} should be created for use by build processes started by the daemon.  Having several such users allows the daemon to launch distinct build processes under separate UIDs, which guarantees that they do not interfere with each other---an essential feature since builds are regarded as pure functions (@pxref{Introduction})."
msgstr "Quando @command{guix-daemon} é executado como @code{root}, você pode não querer que os próprios processos de compilação de pacotes também sejam executados como @code{root}, por razões óbvias de segurança. Para evitar isso, um conjunto especial de @dfn{usuários de compilação} deve ser criado para uso pelos processos de construção iniciados pelo daemon. Ter vários desses usuários permite que o daemon ative processos de compilação distintos sob UIDs separados, o que garante que eles não interfiram uns com os outros - um recurso essencial, pois as compilações são consideradas funções puras (@pxref{Introduction})."

msgid "On a GNU/Linux system, a build user pool may be created like this (using Bash syntax and the @code{shadow} commands):"
msgstr "Em um sistema GNU/Linux, um conjunto de usuários de construção pode ser criado assim (usando a sintaxe Bash e os comandos @code{shadow}):"

msgid "The number of build users determines how many build jobs may run in parallel, as specified by the @option{--max-jobs} option (@pxref{Invoking guix-daemon, @option{--max-jobs}}).  To use @command{guix system vm} and related commands, you may need to add the build users to the @code{kvm} group so they can access @file{/dev/kvm}, using @code{-G guixbuild,kvm} instead of @code{-G guixbuild} (@pxref{Invoking guix system})."
msgstr "O número de usuários de compilação determina quantos trabalhos de compilação podem ser executados em paralelo, conforme especificado pela opção @option{--max-jobs} (@pxref{Invoking guix-daemon, @option{--max-jobs}}). Para usar @command{guix system vm} e comandos relacionados, você pode precisar adicionar os usuários de compilação ao grupo @code{kvm} para que eles possam acessar @file{/dev/kvm}, usando @code{-G guixbuild,kvm} em vez de @code{-G guixbuild} (@pxref{Invoking guix system})."

msgid "# guix-daemon --build-users-group=guixbuild\n"
msgstr "# guix-daemon --build-users-group=guixbuild\n"

msgid "chroot"
msgstr "chroot"

msgid "a minimal @code{/dev} directory, created mostly independently from the host @code{/dev}@footnote{``Mostly'', because while the set of files that appear in the chroot's @code{/dev} is fixed, most of these files can only be created if the host has them.};"
msgstr "um diretório @code{/dev} mínimo, criado principalmente independentemente do @code{/dev} do hospedeiro@footnote{``Principalmente'' porque enquanto o conjunto de arquivos que aparece no @code{/dev} do chroot é corrigido, a maioria desses arquivos só pode ser criada se o hospedeiro os possuir.};"

msgid "the @code{/proc} directory; it only shows the processes of the container since a separate PID name space is used;"
msgstr "o diretório @code{/proc}; mostra apenas os processos do contêiner desde que um espaço de nome PID separado é usado;"

msgid "@file{/etc/passwd} with an entry for the current user and an entry for user @file{nobody};"
msgstr "@file{/etc/passwd} com uma entrada para o usuário atual e uma entrada para o usuário @file{nobody};"

msgid "@file{/etc/group} with an entry for the user's group;"
msgstr "@file{/etc/group} com uma entrada para o grupo de usuários;"

msgid "@file{/etc/hosts} with an entry that maps @code{localhost} to @code{127.0.0.1};"
msgstr "@file{/etc/hosts} com uma entrada que mapeia @code{localhost} para @code{127.0.0.1};"

msgid "a writable @file{/tmp} directory."
msgstr "um diretório @file{/tmp} com permissão de escrita."

msgid "The chroot does not contain a @file{/home} directory, and the @env{HOME} environment variable is set to the non-existent @file{/homeless-shelter}.  This helps to highlight inappropriate uses of @env{HOME} in the build scripts of packages."
msgstr "O chroot não contém um diretório @file{/home}, e a variável de ambiente @env{HOME} é definida como o inexistente @file{/homeless-shelter}. Isso ajuda a destacar usos inapropriados de @env{HOME} nos scripts de construção de pacotes."

msgid "All this is usually enough to ensure details of the environment do not influence build processes.  In some exceptional cases where more control is needed---typically over the date, kernel, or CPU---you can resort to a virtual build machine (@pxref{build-vm, virtual build machines})."
msgstr "Tudo isso geralmente é suficiente para garantir que os detalhes do ambiente não influenciem os processos de construção. Em alguns casos excepcionais em que mais controle é necessário --- normalmente sobre a data, kernel ou CPU --- você pode recorrer a uma máquina de construção virtual (@pxref{build-vm, máquinas de construção virtual})."

msgid "You can influence the directory where the daemon stores build trees @i{via} the @env{TMPDIR} environment variable.  However, the build tree within the chroot is always called @file{/tmp/guix-build-@var{name}.drv-0}, where @var{name} is the derivation name---e.g., @code{coreutils-8.24}.  This way, the value of @env{TMPDIR} does not leak inside build environments, which avoids discrepancies in cases where build processes capture the name of their build tree."
msgstr "Você pode influenciar o diretório onde o daemon armazena árvores de build @i{via} a variável de ambiente @env{TMPDIR}. No entanto, a árvore de build dentro do chroot é sempre chamada @file{/tmp/guix-build-@var{name}.drv-0}, onde @var{name} é o nome da derivação---por exemplo, @code{coreutils-8.24}. Dessa forma, o valor de @env{TMPDIR} não vaza dentro de ambientes de build, o que evita discrepâncias em casos em que os processos de build capturam o nome de sua árvore de build."

msgid "http_proxy"
msgstr "http_proxy"

msgid "https_proxy"
msgstr "https_proxy"

msgid "The daemon also honors the @env{http_proxy} and @env{https_proxy} environment variables for HTTP and HTTPS downloads it performs, be it for fixed-output derivations (@pxref{Derivations}) or for substitutes (@pxref{Substitutes})."
msgstr "O daemon também respeita as variáveis de ambiente @env{http_proxy} e @env{https_proxy} para downloads HTTP e HTTPS que ele realiza, seja para derivações de saída fixa (@pxref{Derivations}) ou para substitutos (@pxref{Substitutes})."

msgid "Using the Offload Facility"
msgstr "Usando o recurso de descarregamento"

msgid "offloading"
msgstr "descarregamento"

msgid "build hook"
msgstr "hook de compilação"

msgid "When desired, the build daemon can @dfn{offload} derivation builds to other machines running Guix, using the @code{offload} @dfn{build hook}@footnote{This feature is available only when @uref{https://github.com/artyom-poptsov/guile-ssh, Guile-SSH} is present.}.  When that feature is enabled, a list of user-specified build machines is read from @file{/etc/guix/machines.scm}; every time a build is requested, for instance via @code{guix build}, the daemon attempts to offload it to one of the machines that satisfy the constraints of the derivation, in particular its system types---e.g., @code{x86_64-linux}.  A single machine can have multiple system types, either because its architecture natively supports it, via emulation (@pxref{transparent-emulation-qemu, Transparent Emulation with QEMU}), or both.  Missing prerequisites for the build are copied over SSH to the target machine, which then proceeds with the build; upon success the output(s) of the build are copied back to the initial machine.  The offload facility comes with a basic scheduler that attempts to select the best machine.  The best machine is chosen among the available machines based on criteria such as:"
msgstr "Quando desejado, o daemon de compilação pode @dfn{offload} compilações de derivação para outras máquinas executando Guix, usando o @code{offload} @dfn{build hook}@footnote{Este recurso está disponível somente quando @uref{https://github.com/artyom-poptsov/guile-ssh, Guile-SSH} está presente.}. Quando esse recurso é habilitado, uma lista de máquinas de compilação especificadas pelo usuário é lida de @file{/etc/guix/machines.scm}; toda vez que uma compilação é solicitada, por exemplo via @code{guix build}, o daemon tenta descarregá-la para uma das máquinas que satisfazem as restrições da derivação, em particular seus tipos de sistema --- por exemplo, @code{x86_64-linux}. Uma única máquina pode ter vários tipos de sistema, seja porque sua arquitetura o suporta nativamente, via emulação (@pxref{transparent-emulation-qemu, Transparent Emulation with QEMU}), ou ambos. Os pré-requisitos ausentes para a compilação são copiados por SSH para a máquina de destino, que então prossegue com a compilação; em caso de sucesso, a(s) saída(s) da compilação são copiadas de volta para a máquina inicial. O recurso de offload vem com um agendador básico que tenta selecionar a melhor máquina. A melhor máquina é escolhida entre as máquinas disponíveis com base em critérios como:"

msgid "The availability of a build slot.  A build machine can have as many build slots (connections) as the value of the @code{parallel-builds} field of its @code{build-machine} object."
msgstr "A disponibilidade de um slot de build. Uma máquina de build pode ter tantos slots de build (conexões) quanto o valor do campo @code{parallel-builds} do seu objeto @code{build-machine}."

msgid "Its relative speed, as defined via the @code{speed} field of its @code{build-machine} object."
msgstr "Sua velocidade relativa, conforme definida pelo campo @code{speed} do seu objeto @code{build-machine}."

msgid "Its load.  The normalized machine load must be lower than a threshold value, configurable via the @code{overload-threshold} field of its @code{build-machine} object."
msgstr "Sua carga. A carga normalizada da máquina deve ser menor que um valor limite, configurável por meio do campo @code{overload-threshold} de seu objeto @code{build-machine}."

msgid "Disk space availability.  More than 100 MiB must be available."
msgstr "Disponibilidade de espaço em disco. Mais de 100 MiB devem estar disponíveis."

msgid "The @file{/etc/guix/machines.scm} file typically looks like this:"
msgstr "O arquivo @file{/etc/guix/machines.scm} geralmente se parece com isso:"

msgid ""
"(list (build-machine\n"
"        (name \"eightysix.example.org\")\n"
"        (systems (list \"x86_64-linux\" \"i686-linux\"))\n"
"        (host-key \"ssh-ed25519 AAAAC3Nza@dots{}\")\n"
"        (user \"bob\")\n"
"        (speed 2.))     ;incredibly fast!\n"
"\n"
msgstr ""
"(list (build-machine\n"
"        (name \"eightysix.example.org\")\n"
"        (systems (list \"x86_64-linux\" \"i686-linux\"))\n"
"        (host-key \"ssh-ed25519 AAAAC3Nza@dots{}\")\n"
"        (user \"bob\")\n"
"        (speed 2.))     ;incredibly fast!\n"
"\n"

msgid ""
"      (build-machine\n"
"        (name \"armeight.example.org\")\n"
"        (systems (list \"aarch64-linux\"))\n"
"        (host-key \"ssh-rsa AAAAB3Nza@dots{}\")\n"
"        (user \"alice\")\n"
"\n"
msgstr ""
"      (build-machine\n"
"        (name \"armeight.example.org\")\n"
"        (systems (list \"aarch64-linux\"))\n"
"        (host-key \"ssh-rsa AAAAB3Nza@dots{}\")\n"
"        (user \"alice\")\n"
"\n"

msgid ""
"        ;; Remember 'guix offload' is spawned by\n"
"        ;; 'guix-daemon' as root.\n"
"        (private-key \"/root/.ssh/identity-for-guix\")))\n"
msgstr ""
"        ;; Lembre-se de que 'guix offload' é gerado por\n"
"        ;; 'guix-daemon' como root.\n"
"        (private-key \"/root/.ssh/identity-for-guix\")))\n"

msgid "In the example above we specify a list of two build machines, one for the @code{x86_64} and @code{i686} architectures and one for the @code{aarch64} architecture."
msgstr "No exemplo acima, especificamos uma lista de duas máquinas de compilação, uma para as arquiteturas @code{x86_64} e @code{i686} e uma para a arquitetura @code{aarch64}."

msgid "In fact, this file is---not surprisingly!---a Scheme file that is evaluated when the @code{offload} hook is started.  Its return value must be a list of @code{build-machine} objects.  While this example shows a fixed list of build machines, one could imagine, say, using DNS-SD to return a list of potential build machines discovered in the local network (@pxref{Introduction, Guile-Avahi,, guile-avahi, Using Avahi in Guile Scheme Programs}).  The @code{build-machine} data type is detailed below."
msgstr "De fato, esse arquivo é -- não surpreendentemente! -- um arquivo de Scheme que é avaliado quando o hook @code{offload} é iniciado. Seu valor de retorno deve ser uma lista de objetos de @code{build-machine}. Embora este exemplo mostre uma lista fixa de máquinas de compilação, pode-se imaginar, digamos, usando DNS-SD para retornar uma lista de possíveis máquinas de compilação descobertas na rede local (@pxref{Introduction, Guile-Avahi ,, guile-avahi, Using Avahi in Guile Scheme Programs}). O tipo de dados de @code{build-machine} está detalhado abaixo."

msgid "{Data Type} build-machine"
msgstr "{Tipo de dados} build-machine"

msgid "This data type represents build machines to which the daemon may offload builds.  The important fields are:"
msgstr "Esse tipo de dados representa máquinas de compilação nas quais o daemon pode descarregar compilações. Os campos importantes são:"

msgid "name"
msgstr "name"

msgid "The host name of the remote machine."
msgstr "O nome de host da máquina remota."

msgid "systems"
msgstr "systems"

msgid "The system types the remote machine supports---e.g., @code{(list \"x86_64-linux\" \"i686-linux\")}."
msgstr "O sistema digita os tipos que a máquina remota suporta, por exemplo, @code{(list \"x86_64-linux\" \"i686-linux\")}."

msgid "user"
msgstr "user"

msgid "host-key"
msgstr "host-key"

msgid "This must be the machine's SSH @dfn{public host key} in OpenSSH format.  This is used to authenticate the machine when we connect to it.  It is a long string that looks like this:"
msgstr "Essa deve ser a SSH @dfn{chave pública do host} da máquina no formato OpenSSH. Isso é usado para autenticar a máquina quando nos conectamos a ela. É uma string longa que se parece com isso:"

msgid "ssh-ed25519 AAAAC3NzaC@dots{}mde+UhL hint@@example.org\n"
msgstr "ssh-ed25519 AAAAC3NzaC@dots{}mde+UhL hint@@example.org\n"

msgid "If the machine is running the OpenSSH daemon, @command{sshd}, the host key can be found in a file such as @file{/etc/ssh/ssh_host_ed25519_key.pub}."
msgstr "Se a máquina estiver executando o daemon OpenSSH, @command{sshd}, a chave do host poderá ser encontrada em um arquivo como @file{/etc/ssh/ssh_host_ed25519_key.pub}."

msgid "A number of optional fields may be specified:"
msgstr "Vários campos opcionais podem ser especificados:"

msgid "@code{port} (default: @code{22})"
msgstr "@code{port} (padrão: @code{22})"

msgid "Port number of SSH server on the machine."
msgstr "O número da porta para o servidor SSH na máquina."

msgid "@code{private-key} (default: @file{~root/.ssh/id_rsa})"
msgstr "@code{private-key} (padrão: @file{~root/.ssh/id_rsa})"

msgid "The SSH private key file to use when connecting to the machine, in OpenSSH format.  This key must not be protected with a passphrase."
msgstr "O arquivo de chave privada SSH a ser usado ao conectar-se à máquina, no formato OpenSSH. Esta chave não deve ser protegida com uma senha."

msgid "Note that the default value is the private key @emph{of the root account}.  Make sure it exists if you use the default."
msgstr "Observe que o valor padrão é a chave privada @emph{da usuário root}. Verifique se ele existe se você usar o padrão."

msgid "@code{compression} (default: @code{\"zlib@@openssh.com,zlib\"})"
msgstr "@code{compression} (padrão: @code{\"zlib@@openssh.com,zlib\"})"

msgid "@code{compression-level} (default: @code{3})"
msgstr "@code{compression-level} (padrão: @code{3})"

msgid "The SSH-level compression methods and compression level requested."
msgstr "Os métodos de compactação no nível SSH e o nível de compactação solicitado."

msgid "Note that offloading relies on SSH compression to reduce bandwidth usage when transferring files to and from build machines."
msgstr "Observe que o descarregamento depende da compactação SSH para reduzir o uso da largura de banda ao transferir arquivos de e para máquinas de compilação."

msgid "@code{daemon-socket} (default: @code{\"/var/guix/daemon-socket/socket\"})"
msgstr "@code{daemon-socket} (padrão: @code{\"/var/guix/daemon-socket/socket\"})"

msgid "File name of the Unix-domain socket @command{guix-daemon} is listening to on that machine."
msgstr "O nome do arquivo do soquete do domínio Unix @command{guix-daemon} está escutando nessa máquina."

msgid "The load threshold above which a potential offload machine is disregarded by the offload scheduler.  The value roughly translates to the total processor usage of the build machine, ranging from 0.0 (0%) to 1.0 (100%).  It can also be disabled by setting @code{overload-threshold} to @code{#f}."
msgstr "O limite de carga acima do qual uma máquina de offload potencial é desconsiderada pelo agendador de offload. O valor traduz aproximadamente o uso total do processador da máquina de build, variando de 0,0 (0%) a 1,0 (100%). Ele também pode ser desabilitado definindo @code{overload-threshold} para @code{#f}."

msgid "@code{parallel-builds} (default: @code{1})"
msgstr "@code{parallel-builds} (padrão: @code{1})"

msgid "The number of builds that may run in parallel on the machine."
msgstr "O número de compilações que podem ser executadas paralelamente na máquina."

msgid "@code{speed} (default: @code{1.0})"
msgstr "@code{speed} (padrão: @code{1.0})"

msgid "A ``relative speed factor''.  The offload scheduler will tend to prefer machines with a higher speed factor."
msgstr "Um ``fator de velocidade relativo''. O agendador de descarregamento tenderá a preferir máquinas com um fator de velocidade mais alto."

msgid "@code{features} (default: @code{'()})"
msgstr "@code{features} (padrão: @code{'()})"

msgid "A list of strings denoting specific features supported by the machine.  An example is @code{\"kvm\"} for machines that have the KVM Linux modules and corresponding hardware support.  Derivations can request features by name, and they will be scheduled on matching build machines."
msgstr "Uma lista de strgins que denotam recursos específicos suportados pela máquina. Um exemplo é @code{\"kvm\"} para máquinas que possuem os módulos KVM Linux e o suporte de hardware correspondente. As derivações podem solicitar recursos pelo nome e serão agendadas nas máquinas de compilação correspondentes."

msgid "On Guix System, instead of managing @file{/etc/guix/machines.scm} independently, you can choose to specify build machines directly in the @code{operating-system} declaration, in the @code{build-machines} field of @code{guix-configuration}.  @xref{guix-configuration-build-machines, @code{build-machines} field of @code{guix-configuration}}."
msgstr "No Guix System, em vez de gerenciar @file{/etc/guix/machines.scm} de forma independente, você pode escolher especificar máquinas de compilação diretamente na declaração @code{operating-system}, no campo @code{build-machines} de @code{guix-configuration}. @xref{guix-configuration-build-machines, campo @code{build-machines} de @code{guix-configuration}}."

msgid "The @command{guix} command must be in the search path on the build machines.  You can check whether this is the case by running:"
msgstr "O comando @command{guix} deve estar no caminho de pesquisa nas máquinas de compilação. Você pode verificar se este é o caso executando:"

msgid "ssh build-machine guix repl --version\n"
msgstr "ssh build-machine guix repl --version\n"

msgid "There is one last thing to do once @file{machines.scm} is in place.  As explained above, when offloading, files are transferred back and forth between the machine stores.  For this to work, you first need to generate a key pair on each machine to allow the daemon to export signed archives of files from the store (@pxref{Invoking guix archive}):"
msgstr "Há uma última coisa a fazer quando o @file{machines.scm} está em vigor. Como explicado acima, ao descarregar, os arquivos são transferidos entre os armazéns das máquinas. Para que isso funcione, primeiro você precisa gerar um par de chaves em cada máquina para permitir que o daemon exporte arquivos assinados de arquivos do armazém (@pxref{Invoking guix archive}):"

msgid "# guix archive --generate-key\n"
msgstr "# guix archive --generate-key\n"

msgid "This key pair is not related to the SSH key pair that was previously mentioned in the description of the @code{build-machine} data type."
msgstr "Este par de chaves não está relacionado ao par de chaves SSH mencionado anteriormente na descrição do tipo de dados @code{build-machine}."

msgid "Each build machine must authorize the key of the master machine so that it accepts store items it receives from the master:"
msgstr "Cada máquina de construção deve autorizar a chave da máquina principal para que ela aceite itens do armazém que recebe do mestre:"

msgid "# guix archive --authorize < master-public-key.txt\n"
msgstr "# guix archive --authorize < master-public-key.txt\n"

msgid "Likewise, the master machine must authorize the key of each build machine."
msgstr "Da mesma forma, a máquina principal deve autorizar a chave de cada máquina de compilação."

msgid "All the fuss with keys is here to express pairwise mutual trust relations between the master and the build machines.  Concretely, when the master receives files from a build machine (and @i{vice versa}), its build daemon can make sure they are genuine, have not been tampered with, and that they are signed by an authorized key."
msgstr "Todo esse barulho com as chaves está aqui para expressar relações de confiança mútua de pares entre a máquina mestre e as de compilação. Concretamente, quando o mestre recebe arquivos de uma máquina de compilação (e @i{vice-versa}), seu daemon de compilação pode garantir que eles sejam genuínos, não tenham sido violados e que sejam assinados por uma chave autorizada."

msgid "offload test"
msgstr "offload test"

msgid "To test whether your setup is operational, run this command on the master node:"
msgstr "Para testar se sua configuração está operacional, execute este comando no nó principal:"

msgid "# guix offload test\n"
msgstr "# guix offload test\n"

msgid "This will attempt to connect to each of the build machines specified in @file{/etc/guix/machines.scm}, make sure Guix is available on each machine, attempt to export to the machine and import from it, and report any error in the process."
msgstr "Isso tentará se conectar a cada uma das máquinas de compilação especificadas em @file{/etc/guix/machines.scm}, certificar-se de que o Guix esteja disponível em cada máquina, tentará exportar para a máquina e importar dela e relatará qualquer erro no processo."

msgid "If you want to test a different machine file, just specify it on the command line:"
msgstr "Se você quiser testar um arquivo de máquina diferente, basta especificá-lo na linha de comando:"

msgid "# guix offload test machines-qualif.scm\n"
msgstr "# guix offload test machines-qualif.scm\n"

msgid "Last, you can test the subset of the machines whose name matches a regular expression like this:"
msgstr "Por fim, você pode testar o subconjunto das máquinas cujo nome corresponde a uma expressão regular como esta:"

msgid "# guix offload test machines.scm '\\.gnu\\.org$'\n"
msgstr "# guix offload test machines.scm '\\.gnu\\.org$'\n"

msgid "offload status"
msgstr "offload status"

msgid "To display the current load of all build hosts, run this command on the main node:"
msgstr "Para exibir o carregamento atual de todos os hosts de compilação, execute este comando no nó principal:"

msgid "# guix offload status\n"
msgstr "# guix offload status\n"

msgid "SELinux, daemon policy"
msgstr "SELinux, política de daemons"

msgid "mandatory access control, SELinux"
msgstr "controle de acesso obrigatório, SELinux"

msgid "security, guix-daemon"
msgstr "segurança, guix-daemon"

msgid "Guix includes an SELinux policy file at @file{etc/guix-daemon.cil} that can be installed on a system where SELinux is enabled, in order to label Guix files and to specify the expected behavior of the daemon.  Since Guix System does not provide an SELinux base policy, the daemon policy cannot be used on Guix System."
msgstr "O Guix inclui um arquivo de políticas do SELinux em @file{etc/guix-daemon.cil} que pode ser instalado em um sistema em que o SELinux está ativado, para rotular os arquivos do Guix e especificar o comportamento esperado do daemon. Como o Guix System não fornece uma política básica do SELinux, a política do daemon não pode ser usada no Guix System."

msgid "Installing the SELinux policy"
msgstr "Instalando a política do SELinux"

msgid "SELinux, policy installation"
msgstr "SELinux, instalação de política"

msgid "The @code{guix-install.sh} binary installation script offers to perform the steps below for you (@pxref{Binary Installation})."
msgstr "O script de instalação binária @code{guix-install.sh} se oferece para executar as etapas abaixo para você (@pxref{Binary Installation})."

msgid "To install the policy run this command as root:"
msgstr "Para instalar a política, execute esse comando como root:"

msgid "Then, as root, relabel the file system, possibly after making it writable:"
msgstr "Então, como root, renomeie o sistema de arquivos, possivelmente depois de torná-lo gravável:"

msgid ""
"mount -o remount,rw /gnu/store\n"
"restorecon -R /gnu /var/guix\n"
msgstr ""
"mount -o remount,rw /gnu/store\n"
"restorecon -R /gnu /var/guix\n"

msgid "At this point you can start or restart @command{guix-daemon}; on a distribution that uses systemd as its service manager, you can do that with:"
msgstr "Neste ponto, você pode iniciar ou reiniciar @command{guix-daemon}; em uma distribuição que usa systemd como seu gerenciador de serviços, você pode fazer isso com:"

msgid "Once the policy is installed, the file system has been relabeled, and the daemon has been restarted, it should be running in the @code{guix_daemon_t} context.  You can confirm this with the following command:"
msgstr "Depois que a política é instalada, o sistema de arquivos foi rotulado novamente e o daemon foi reiniciado, ele deve estar em execução no contexto @code{guix_daemon_t}. Você pode confirmar isso com o seguinte comando:"

msgid "ps -Zax | grep guix-daemon\n"
msgstr "ps -Zax | grep guix-daemon\n"

msgid "Monitor the SELinux log files as you run a command like @code{guix build hello} to convince yourself that SELinux permits all necessary operations."
msgstr "Monitore os arquivos de log do SELinux enquanto executa um comando como @code{guix build hello} para se convencer de que o SELinux permite todas as operações necessárias."

msgid "SELinux, limitations"
msgstr "SELinux, limitações"

msgid "This policy is not perfect.  Here is a list of limitations or quirks that should be considered when deploying the provided SELinux policy for the Guix daemon."
msgstr "Esta política não é perfeita. Aqui está uma lista de limitações ou peculiaridades que devem ser consideradas ao implementar a política SELinux fornecida para o daemon Guix."

msgid "@code{guix gc} cannot access arbitrary links to profiles.  By design, the file label of the destination of a symlink is independent of the file label of the link itself.  Although all profiles under @file{$localstatedir} are labelled, the links to these profiles inherit the label of the directory they are in.  For links in the user’s home directory this will be @code{user_home_t}.  But for links from the root user’s home directory, or @file{/tmp}, or the HTTP server’s working directory, etc, this won’t work.  @code{guix gc} would be prevented from reading and following these links."
msgstr "@code{guix gc} não pode acessar links arbitrários para perfis. Por design, o rótulo do arquivo do destino de uma ligação simbólica é independente do rótulo do arquivo do próprio link. Embora todos os perfis em @file{$localstatedir} estejam rotulados, as ligações para esses perfis herdam o rótulo do diretório em que estão. Para as ligações no diretório pessoal do usuário, será @code{user_home_t}. Mas, para ligações do diretório pessoal do usuário root, ou @file{/tmp}, ou do diretório de trabalho do servidor HTTP etc., isso não funcionará. @code{guix gc} seria impedido de ler e seguir essas ligações."

msgid "The daemon’s feature to listen for TCP connections might no longer work.  This might require extra rules, because SELinux treats network sockets differently from files."
msgstr "O recurso do daemon de escutar conexões TCP pode não funcionar mais. Isso pode exigir regras extras, porque o SELinux trata os soquetes de rede de maneira diferente dos arquivos."

msgid "Currently all files with a name matching the regular expression @code{/gnu/store/.+-(guix-.+|profile)/bin/guix-daemon} are assigned the label @code{guix_daemon_exec_t}; this means that @emph{any} file with that name in any profile would be permitted to run in the @code{guix_daemon_t} domain.  This is not ideal.  An attacker could build a package that provides this executable and convince a user to install and run it, which lifts it into the @code{guix_daemon_t} domain.  At that point SELinux could not prevent it from accessing files that are allowed for processes in that domain."
msgstr "Atualmente, todos os arquivos com um nome correspondente à expressão regular @code{/gnu/store/.+-(guix-.+|profile)/bin/guix-daemon} recebem o rótulo @code{guix_daemon_exec_t}; isso significa que @emph{qualquer} arquivo com esse nome em qualquer perfil poderá ser executado no domínio de @code{guix_daemon_t}. Isto não é o ideal. Um invasor pode criar um pacote que forneça esse executável e convencer um usuário a instalar e executá-lo, o que o eleva ao domínio de @code{guix_daemon_t}. Nesse ponto, o SELinux não poderia impedir o acesso a arquivos permitidos para processos nesse domínio."

msgid "You will need to relabel the store directory after all upgrades to @file{guix-daemon}, such as after running @code{guix pull}.  Assuming the store is in @file{/gnu}, you can do this with @code{restorecon -vR /gnu}, or by other means provided by your operating system."
msgstr "Você precisará renomear o diretório store após todas as atualizações para @file{guix-daemon}, como após executar @code{guix pull}. Supondo que o store esteja em @file{/gnu}, você pode fazer isso com @code{restorecon -vR /gnu}, ou por outros meios fornecidos pelo seu sistema operacional."

msgid "We could generate a much more restrictive policy at installation time, so that only the @emph{exact} file name of the currently installed @code{guix-daemon} executable would be labelled with @code{guix_daemon_exec_t}, instead of using a broad regular expression.  The downside is that root would have to install or upgrade the policy at installation time whenever the Guix package that provides the effectively running @code{guix-daemon} executable is upgraded."
msgstr "Poderíamos gerar uma política muito mais restritiva no momento da instalação, para que apenas o nome do arquivo @emph{exato} do executável @code{guix-daemon} atualmente instalado seja rotulado com @code{guix_daemon_exec_t}, em vez de usar um amplo expressão regular. A desvantagem é que o root precisaria instalar ou atualizar a política no momento da instalação sempre que o pacote Guix que fornece o executável @code{guix-daemon} em execução efetiva for atualizado."

msgid "Invoking @command{guix-daemon}"
msgstr "Invocando @command{guix-daemon}"

msgid "The @command{guix-daemon} program implements all the functionality to access the store.  This includes launching build processes, running the garbage collector, querying the availability of a build result, etc.  It is normally run as @code{root} like this:"
msgstr "O programa @command{guix-daemon} implementa todas as funcionalidades para acessar o armazém. Isso inclui iniciar processos de compilação, executar o coletor de lixo, consultar a disponibilidade de um resultado da compilação etc. É normalmente executado como @code{root}, assim:"

msgid "This daemon can also be started following the systemd ``socket activation'' protocol (@pxref{Service De- and Constructors, @code{make-systemd-constructor},, shepherd, The GNU Shepherd Manual})."
msgstr "Este daemon também pode ser iniciado seguindo o protocolo de ``ativação de soquete'' do systemd (@pxref{Service De- and Constructors, @code{make-systemd-constructor},, shepherd, The GNU Shepherd Manual})."

msgid "For details on how to set it up, @pxref{Setting Up the Daemon}."
msgstr "Para detalhes sobre como configurá-lo, @pxref{Setting Up the Daemon}."

msgid "container, build environment"
msgstr "contêiner, ambiente de compilação"

msgid "reproducible builds"
msgstr "compilações reproduzíveis"

msgid "By default, @command{guix-daemon} launches build processes under different UIDs, taken from the build group specified with @option{--build-users-group}.  In addition, each build process is run in a chroot environment that only contains the subset of the store that the build process depends on, as specified by its derivation (@pxref{Programming Interface, derivation}), plus a set of specific system directories.  By default, the latter contains @file{/dev} and @file{/dev/pts}.  Furthermore, on GNU/Linux, the build environment is a @dfn{container}: in addition to having its own file system tree, it has a separate mount name space, its own PID name space, network name space, etc.  This helps achieve reproducible builds (@pxref{Features})."
msgstr "Por padrão, @command{guix-daemon} inicia processos de compilação sob diferentes UIDs, obtidos do grupo de compilação especificado com @option{--build-users-group}. Além disso, cada processo de compilação é executado em um ambiente chroot que contém apenas o subconjunto do armazém do qual o processo de compilação depende, conforme especificado por sua derivação (@pxref{Programming Interface, derivação}), mais um conjunto de diretórios de sistema específicos. Por padrão, o último contém @file{/dev} e @file{/dev/pts}. Além disso, no GNU/Linux, o ambiente de compilação é um @dfn{container}: além de ter sua própria árvore de sistema de arquivos, ele tem um espaço de nome de montagem separado, seu próprio espaço de nome PID, espaço de nome de rede, etc. Isso ajuda a obter compilações reproduzíveis (@pxref{Features})."

msgid "When the daemon performs a build on behalf of the user, it creates a build directory under @file{/tmp} or under the directory specified by its @env{TMPDIR} environment variable.  This directory is shared with the container for the duration of the build, though within the container, the build tree is always called @file{/tmp/guix-build-@var{name}.drv-0}."
msgstr "Quando o daemon executa uma compilação em nome do usuário, ele cria um diretório de compilação em @file{/tmp} ou no diretório especificado por sua variável de ambiente @env{TMPDIR}. Esse diretório é compartilhado com o contêiner durante a compilação, embora dentro do contêiner, a árvore de compilação seja sempre chamada de @file{/tmp/guix-build-@var{name}.drv-0}."

msgid "The build directory is automatically deleted upon completion, unless the build failed and the client specified @option{--keep-failed} (@pxref{Common Build Options, @option{--keep-failed}})."
msgstr "O diretório de compilação é excluído automaticamente após a conclusão, a menos que a compilação falhe e o cliente tenha especificado @option{--keep-failed} (@pxref{Common Build Options, @option{--keep-failed}})."

msgid "The daemon listens for connections and spawns one sub-process for each session started by a client (one of the @command{guix} sub-commands).  The @command{guix processes} command allows you to get an overview of the activity on your system by viewing each of the active sessions and clients.  @xref{Invoking guix processes}, for more information."
msgstr "O daemon escuta conexões e gera um subprocesso para cada sessão iniciada por um cliente (um dos subcomandos @command{guix}). O comando @command{guix processes} permite que você tenha uma visão geral da atividade no seu sistema visualizando cada uma das sessões e clientes ativos. @xref{Invoking guix processes}, para mais informações."

msgid "The following command-line options are supported:"
msgstr "As seguintes opções de linha de comando são suportadas:"

msgid "--build-users-group=@var{group}"
msgstr "--build-users-group=@var{grupo}"

msgid "Take users from @var{group} to run build processes (@pxref{Setting Up the Daemon, build users})."
msgstr "Obtém os usuários do @var{grupo} para executar os processos de compilação (@pxref{Setting Up the Daemon, usuários de compilação})."

msgid "--no-substitutes"
msgstr "--no-substitutes"

msgid "substitutes"
msgstr "substitutos"

msgid "Do not use substitutes for build products.  That is, always build things locally instead of allowing downloads of pre-built binaries (@pxref{Substitutes})."
msgstr "Não use substitutos para compilar produtos. Ou seja, sempre crie coisas localmente, em vez de permitir downloads de binários pré-compilados (@pxref{Substitutes})."

msgid "When the daemon runs with @option{--no-substitutes}, clients can still explicitly enable substitution @i{via} the @code{set-build-options} remote procedure call (@pxref{The Store})."
msgstr "Quando o daemon é executado com @option{--no-substitutes}, os clientes ainda podem habilitar explicitamente a substituição por meio da chamada de procedimento remoto @code{set-build-options} (@pxref{The Store})."

msgid "daemon-substitute-urls"
msgstr "daemon-substitute-urls"

msgid "--substitute-urls=@var{urls}"
msgstr "--substitute-urls=@var{urls}"

msgid "This means that substitutes may be downloaded from @var{urls}, as long as they are signed by a trusted signature (@pxref{Substitutes})."
msgstr "Isso significa que os substitutos podem ser baixados de @var{urls}, desde que assinados por uma assinatura confiável (@pxref{Substitutes})."

msgid "@xref{Getting Substitutes from Other Servers}, for more information on how to configure the daemon to get substitutes from other servers."
msgstr "@xref{Getting Substitutes from Other Servers}, para mais informações sobre como configurar o daemon para obter substitutos de outros servidores."

msgid "--no-offload"
msgstr "--no-offload"

msgid "Do not use offload builds to other machines (@pxref{Daemon Offload Setup}).  That is, always build things locally instead of offloading builds to remote machines."
msgstr "Não use compilações de offload para outras máquinas (@pxref{Daemon Offload Setup}). Ou seja, sempre compile as coisas localmente em vez de descarregar compilações para máquinas remotas."

msgid "--cache-failures"
msgstr "--cache-failures"

msgid "Cache build failures.  By default, only successful builds are cached."
msgstr "Armazena em cache as compilações que falharam. Por padrão, apenas compilações bem-sucedidas são armazenadas em cache."

msgid "When this option is used, @command{guix gc --list-failures} can be used to query the set of store items marked as failed; @command{guix gc --clear-failures} removes store items from the set of cached failures.  @xref{Invoking guix gc}."
msgstr "Quando essa opção é usada, o @command{guix gc --list-failures} pode ser usado para consultar o conjunto de itens do armazém marcados como com falha; O @command{guix gc --clear-failures} remove os itens do armazém do conjunto de falhas em cache. @xref{Invoking guix gc}."

msgid "--cores=@var{n}"
msgstr "--cores=@var{n}"

msgid "-c @var{n}"
msgstr "-c @var{n}"

msgid "Use @var{n} CPU cores to build each derivation; @code{0} means as many as available."
msgstr "Usa @var{n} núcleos de CPU para compilar cada derivação; @code{0} significa todos disponíveis."

msgid "The default value is @code{0}, but it may be overridden by clients, such as the @option{--cores} option of @command{guix build} (@pxref{Invoking guix build})."
msgstr "O valor padrão é @code{0}, mas pode ser substituído pelos clientes, como a opção @option{--cores} de @command{guix build} (@pxref{Invoking guix build})."

msgid "The effect is to define the @env{NIX_BUILD_CORES} environment variable in the build process, which can then use it to exploit internal parallelism---for instance, by running @code{make -j$NIX_BUILD_CORES}."
msgstr "O efeito é definir a variável de ambiente @env{NIX_BUILD_CORES} no processo de compilação, que pode então usá-la para explorar o paralelismo interno — por exemplo, executando @code{make -j$NIX_BUILD_CORES}."

msgid "--max-jobs=@var{n}"
msgstr "--max-jobs=@var{n}"

msgid "-M @var{n}"
msgstr "-M @var{n}"

msgid "Allow at most @var{n} build jobs in parallel.  The default value is @code{1}.  Setting it to @code{0} means that no builds will be performed locally; instead, the daemon will offload builds (@pxref{Daemon Offload Setup}), or simply fail."
msgstr "Permite no máximo @var{n} tarefas de compilação em paralelo. O valor padrão é @code{1}. Definir como @code{0} significa que nenhuma compilação será executada localmente; em vez disso, o daemon descarregará as compilações (@pxref{Daemon Offload Setup}) ou simplesmente falhará."

msgid "--max-silent-time=@var{seconds}"
msgstr "--max-silent-time=@var{segundos}"

msgid "When the build or substitution process remains silent for more than @var{seconds}, terminate it and report a build failure."
msgstr "Quando o processo de compilação ou substituição permanecer em silêncio por mais de @var{segundos}, encerra-o e relata uma falha de compilação."

msgid "The value specified here can be overridden by clients (@pxref{Common Build Options, @option{--max-silent-time}})."
msgstr "O valor especificado aqui pode ser substituído pelos clientes (@pxref{Common Build Options, @option{--max-silent-time}})."

msgid "--timeout=@var{seconds}"
msgstr "--timeout=@var{segundos}"

msgid "Likewise, when the build or substitution process lasts for more than @var{seconds}, terminate it and report a build failure."
msgstr "Da mesma forma, quando o processo de compilação ou substituição durar mais que @var{segundos}, encerra-o e relata uma falha de compilação."

msgid "The default value is 24 hours."
msgstr "O valor padrão é 24 horas."

msgid "The value specified here can be overridden by clients (@pxref{Common Build Options, @option{--timeout}})."
msgstr "O valor especificado aqui pode ser substituído pelos clientes (@pxref{Common Build Options, @option{--timeout}})."

msgid "--rounds=@var{N}"
msgstr "--rounds=@var{N}"

msgid "Build each derivation @var{n} times in a row, and raise an error if consecutive build results are not bit-for-bit identical.  Note that this setting can be overridden by clients such as @command{guix build} (@pxref{Invoking guix build})."
msgstr "Compila cada derivação @var{n} vezes seguidas e gera um erro se os resultados consecutivos da compilação não forem idênticos bit a bit. Observe que essa configuração pode ser substituída por clientes como @command{guix build} (@pxref{Invoking guix build})."

msgid "When used in conjunction with @option{--keep-failed}, the differing output is kept in the store, under @file{/gnu/store/@dots{}-check}.  This makes it easy to look for differences between the two results."
msgstr "Quando usado em conjunto com @option{--keep-failed}, uma saída de comparação é mantida no armazém, sob  @file{/gnu/store/@dots{}-check}. Isso facilita procurar por diferenças entre os dois resultados."

msgid "--debug"
msgstr "--debug"

msgid "Produce debugging output."
msgstr "Produz uma saída de depuração."

msgid "This is useful to debug daemon start-up issues, but then it may be overridden by clients, for example the @option{--verbosity} option of @command{guix build} (@pxref{Invoking guix build})."
msgstr "Isso é útil para depurar problemas de inicialização do daemon, mas pode ser substituído pelos clientes, por exemplo, a opção @option{--verbosity} de @command{guix build} (@pxref{Invoking guix build})."

msgid "--chroot-directory=@var{dir}"
msgstr "--chroot-directory=@var{dir}"

msgid "Add @var{dir} to the build chroot."
msgstr "adiciona @var{dir} ao chroot de compilação."

msgid "Doing this may change the result of build processes---for instance if they use optional dependencies found in @var{dir} when it is available, and not otherwise.  For that reason, it is not recommended to do so.  Instead, make sure that each derivation declares all the inputs that it needs."
msgstr "Isso pode alterar o resultado dos processos de compilação -- por exemplo, se eles usam dependências opcionais encontradas em @var{dir} quando estão disponíveis, e não o contrário. Por esse motivo, não é recomendável fazê-lo. Em vez disso, verifique se cada derivação declara todas as entradas necessárias."

msgid "--disable-chroot"
msgstr "--disable-chroot"

msgid "Disable chroot builds."
msgstr "Desabilita compilações em chroot."

msgid "--log-compression=@var{type}"
msgstr "--log-compression=@var{tipo}"

msgid "Compress build logs according to @var{type}, one of @code{gzip}, @code{bzip2}, or @code{none}."
msgstr "Compacta logs de compilação de aconrdo com @var{tipo}, que pode ser um entre @code{gzip}, @code{bzip2} e @code{none}."

msgid "Unless @option{--lose-logs} is used, all the build logs are kept in the @var{localstatedir}.  To save space, the daemon automatically compresses them with gzip by default."
msgstr "A menos que @option{--lose-logs} seja usado, todos os logs de build são mantidos em @var{localstatedir}. Para economizar espaço, o daemon os compacta automaticamente com gzip por padrão."

msgid "--discover[=yes|no]"
msgstr "--discover[=yes|no]"

msgid "Whether to discover substitute servers on the local network using mDNS and DNS-SD."
msgstr "Se deve descobrir servidores substitutos na rede local usando mDNS e DNS-SD."

msgid "This feature is still experimental.  However, here are a few considerations."
msgstr "Este recurso ainda é experimental. No entanto, aqui estão algumas considerações."

msgid "It might be faster/less expensive than fetching from remote servers;"
msgstr "Pode ser mais rápido/menos caro do que buscar em servidores remotos;"

msgid "There are no security risks, only genuine substitutes will be used (@pxref{Substitute Authentication});"
msgstr "Não há riscos de segurança, apenas substitutos genuínos serão usados (@pxref{Substitute Authentication});"

msgid "An attacker advertising @command{guix publish} on your LAN cannot serve you malicious binaries, but they can learn what software you’re installing;"
msgstr "Um invasor anunciando @command{guix publish} na sua LAN não pode fornecer binários maliciosos, mas pode descobrir qual software você está instalando;"

msgid "Servers may serve substitute over HTTP, unencrypted, so anyone on the LAN can see what software you’re installing."
msgstr "Os servidores podem servir substitutos via HTTP, sem criptografia, para que qualquer pessoa na LAN possa ver qual software você está instalando."

msgid "It is also possible to enable or disable substitute server discovery at run-time by running:"
msgstr "Também é possível habilitar ou desabilitar a descoberta de servidor substituto em tempo de execução executando:"

msgid ""
"herd discover guix-daemon on\n"
"herd discover guix-daemon off\n"
msgstr ""
"herd discover guix-daemon on\n"
"herd discover guix-daemon off\n"

msgid "--disable-deduplication"
msgstr "--disable-deduplication"

msgid "deduplication"
msgstr "deduplicação"

msgid "Disable automatic file ``deduplication'' in the store."
msgstr "Desabilita ``deduplicação'' automática de arquivos no armazém."

msgid "By default, files added to the store are automatically ``deduplicated'': if a newly added file is identical to another one found in the store, the daemon makes the new file a hard link to the other file.  This can noticeably reduce disk usage, at the expense of slightly increased input/output load at the end of a build process.  This option disables this optimization."
msgstr "Por padrão, os arquivos adicionados ao armazém são automaticamente ``deduplicados'': se um arquivo recém-adicionado for idêntico a outro encontrado no armazém, o daemon tornará o novo arquivo um link físico para o outro arquivo. Isso pode reduzir notavelmente o uso do disco, às custas de um leve aumento na carga de entrada/saída no final de um processo de criação. Esta opção desativa essa otimização."

msgid "--gc-keep-outputs[=yes|no]"
msgstr "--gc-keep-outputs[=yes|no]"

msgid "Tell whether the garbage collector (GC) must keep outputs of live derivations."
msgstr "Diz se o coletor de lixo (GC) deve manter as saídas de derivações vivas."

msgid "GC roots"
msgstr "raízes de GC"

msgid "garbage collector roots"
msgstr "raízes de coletor de lixo"

msgid "When set to @code{yes}, the GC will keep the outputs of any live derivation available in the store---the @file{.drv} files.  The default is @code{no}, meaning that derivation outputs are kept only if they are reachable from a GC root.  @xref{Invoking guix gc}, for more on GC roots."
msgstr "Quando definido como @code{yes}, o GC manterá as saídas de qualquer derivação ativa disponível no armazém---os arquivos @file{.drv}. O padrão é @code{no}, o que significa que as saídas de derivação são mantidas somente se forem acessíveis a partir de uma raiz do GC. @xref{Invoking guix gc}, para mais informações sobre raízes do GC."

msgid "--gc-keep-derivations[=yes|no]"
msgstr "--gc-keep-derivations[=yes|no]"

msgid "Tell whether the garbage collector (GC) must keep derivations corresponding to live outputs."
msgstr "Diz se o coletor de lixo (GC) deve manter as derivações correspondentes às saídas vivas."

msgid "When set to @code{yes}, as is the case by default, the GC keeps derivations---i.e., @file{.drv} files---as long as at least one of their outputs is live.  This allows users to keep track of the origins of items in their store.  Setting it to @code{no} saves a bit of disk space."
msgstr "Quando definido como @code{yes}, como é o caso por padrão, o GC mantém derivações---ou seja, arquivos @file{.drv}---desde que pelo menos uma de suas saídas esteja ativa. Isso permite que os usuários acompanhem as origens dos itens em seu armazém. Defini-lo como @code{no} economiza um pouco de espaço em disco."

msgid "In this way, setting @option{--gc-keep-derivations} to @code{yes} causes liveness to flow from outputs to derivations, and setting @option{--gc-keep-outputs} to @code{yes} causes liveness to flow from derivations to outputs.  When both are set to @code{yes}, the effect is to keep all the build prerequisites (the sources, compiler, libraries, and other build-time tools) of live objects in the store, regardless of whether these prerequisites are reachable from a GC root.  This is convenient for developers since it saves rebuilds or downloads."
msgstr "Dessa forma, definir @option{--gc-keep-derivations} como @code{yes} faz com que a vivacidade flua das saídas para as derivações, e definir @option{--gc-keep-outputs} como @code{yes} faz com que a vivacidade flua das derivações para as saídas. Quando ambos são definidos como @code{yes}, o efeito é manter todos os pré-requisitos de compilação (as fontes, o compilador, as bibliotecas e outras ferramentas de tempo de compilação) de objetos ativos no armazém, independentemente de esses pré-requisitos serem acessíveis a partir de uma raiz GC. Isso é conveniente para desenvolvedores, pois economiza reconstruções ou downloads."

msgid "--impersonate-linux-2.6"
msgstr "--impersonate-linux-2.6"

msgid "On Linux-based systems, impersonate Linux 2.6.  This means that the kernel's @command{uname} system call will report 2.6 as the release number."
msgstr "Em sistemas baseados em Linux, personifique o Linux 2.6. Isso significa que a chamada de sistema @command{uname} do kernel relatará 2.6 como o número da versão."

msgid "This might be helpful to build programs that (usually wrongfully) depend on the kernel version number."
msgstr "Isso pode ser útil para criar programas que (geralmente de forma errada) dependem do número da versão do kernel."

msgid "--lose-logs"
msgstr "--lose-logs"

msgid "Do not keep build logs.  By default they are kept under @file{@var{localstatedir}/guix/log}."
msgstr "Não mantenha logs de build. Por padrão, eles são mantidos em @file{@var{localstatedir}/guix/log}."

msgid "--system=@var{system}"
msgstr "--system=@var{sistema}"

msgid "Assume @var{system} as the current system type.  By default it is the architecture/kernel pair found at configure time, such as @code{x86_64-linux}."
msgstr "Assuma @var{sistema} como o tipo de sistema atual. Por padrão, é o par arquitetura/kernel encontrado no momento da configuração, como @code{x86_64-linux}."

msgid "--listen=@var{endpoint}"
msgstr "--listen=@var{endpoint}"

msgid "Listen for connections on @var{endpoint}.  @var{endpoint} is interpreted as the file name of a Unix-domain socket if it starts with @code{/} (slash sign).  Otherwise, @var{endpoint} is interpreted as a host name or host name and port to listen to.  Here are a few examples:"
msgstr "Ouça conexões em @var{endpoint}. @var{endpoint} é interpretado como o nome do arquivo de um soquete de domínio Unix se ele começar com @code{/} (sinal de barra). Caso contrário, @var{endpoint} é interpretado como um nome de host ou nome de host e porta para ouvir. Aqui estão alguns exemplos:"

msgid "--listen=/gnu/var/daemon"
msgstr "--listen=/gnu/var/daemon"

msgid "Listen for connections on the @file{/gnu/var/daemon} Unix-domain socket, creating it if needed."
msgstr "Ouça conexões no soquete de domínio Unix @file{/gnu/var/daemon}, criando-o se necessário."

msgid "--listen=localhost"
msgstr "--listen=localhost"

msgid "daemon, remote access"
msgstr "daemon, acesso remoto"

msgid "remote access to the daemon"
msgstr "acesso remoto ao daemon"

msgid "daemon, cluster setup"
msgstr "daemon, configuração de cluster"

msgid "clusters, daemon setup"
msgstr "clusters, configuração do daemon"

msgid "Listen for TCP connections on the network interface corresponding to @code{localhost}, on port 44146."
msgstr "Ouça as conexões TCP na interface de rede correspondente a @code{localhost}, na porta 44146."

msgid "--listen=128.0.0.42:1234"
msgstr "--listen=128.0.0.42:1234"

msgid "Listen for TCP connections on the network interface corresponding to @code{128.0.0.42}, on port 1234."
msgstr "Ouça as conexões TCP na interface de rede correspondente ao @code{128.0.0.42}, na porta 1234."

msgid "This option can be repeated multiple times, in which case @command{guix-daemon} accepts connections on all the specified endpoints.  Users can tell client commands what endpoint to connect to by setting the @env{GUIX_DAEMON_SOCKET} environment variable (@pxref{The Store, @env{GUIX_DAEMON_SOCKET}})."
msgstr "Esta opção pode ser repetida várias vezes, nesse caso @command{guix-daemon} aceita conexões em todos os endpoints especificados. Os usuários podem informar aos comandos do cliente a qual endpoint se conectar definindo a variável de ambiente @env{GUIX_DAEMON_SOCKET} (@pxref{The Store, @env{GUIX_DAEMON_SOCKET}})."

msgid "The daemon protocol is @emph{unauthenticated and unencrypted}.  Using @option{--listen=@var{host}} is suitable on local networks, such as clusters, where only trusted nodes may connect to the build daemon.  In other cases where remote access to the daemon is needed, we recommend using Unix-domain sockets along with SSH."
msgstr "O protocolo daemon é @emph{unauthenticated and unencrypted}. Usar @option{--listen=@var{host}} é adequado em redes locais, como clusters, onde apenas nós confiáveis podem se conectar ao daemon de compilação. Em outros casos em que o acesso remoto ao daemon é necessário, recomendamos usar soquetes de domínio Unix junto com SSH."

msgid "When @option{--listen} is omitted, @command{guix-daemon} listens for connections on the Unix-domain socket located at @file{@var{localstatedir}/guix/daemon-socket/socket}."
msgstr "Quando @option{--listen} é omitido, @command{guix-daemon} escuta conexões no soquete de domínio Unix localizado em @file{@var{localstatedir}/guix/daemon-socket/socket}."

msgid "When using Guix on top of GNU/Linux distribution other than Guix System---a so-called @dfn{foreign distro}---a few additional steps are needed to get everything in place.  Here are some of them."
msgstr "Ao usar Guix sobre uma distribuição GNU/Linux que não seja um Guix System --- uma chamada @dfn{distro alheia} --- algumas etapas adicionais são necessárias para colocar tudo no seu lugar. Aqui estão algumas delas."

msgid "locales-and-locpath"
msgstr "locales-and-locpath"

msgid "locales, when not on Guix System"
msgstr "locales, quando não está no Guix System"

msgid "LOCPATH"
msgstr "LOCPATH"

msgid "GUIX_LOCPATH"
msgstr "GUIX_LOCPATH"

msgid "Packages installed @i{via} Guix will not use the locale data of the host system.  Instead, you must first install one of the locale packages available with Guix and then define the @env{GUIX_LOCPATH} environment variable:"
msgstr "Pacotes instalados @i{via} Guix não usarão os dados de localidade do sistema host. Em vez disso, você deve primeiro instalar um dos pacotes de localidade disponíveis com Guix e então definir a variável de ambiente @env{GUIX_LOCPATH}:"

msgid ""
"$ guix install glibc-locales\n"
"$ export GUIX_LOCPATH=$HOME/.guix-profile/lib/locale\n"
msgstr ""
"$ guix install glibc-locales\n"
"$ export GUIX_LOCPATH=$HOME/.guix-profile/lib/locale\n"

msgid "Note that the @code{glibc-locales} package contains data for all the locales supported by the GNU@tie{}libc and weighs in at around 930@tie{}MiB@footnote{The size of the @code{glibc-locales} package is reduced down to about 213@tie{}MiB with store deduplication and further down to about 67@tie{}MiB when using a zstd-compressed Btrfs file system.}.  If you only need a few locales, you can define your custom locales package via the @code{make-glibc-utf8-locales} procedure from the @code{(gnu packages base)} module.  The following example defines a package containing the various Canadian UTF-8 locales known to the GNU@tie{}libc, that weighs around 14@tie{}MiB:"
msgstr "Observe que o pacote @code{glibc-locales} contém dados para todos os locais suportados pela GNU@tie{}libc e pesa cerca de 930@tie{}MiB@footnote{O tamanho do pacote @code{glibc-locales} é reduzido para cerca de 213@tie{}MiB com desduplicação de armazém e ainda mais para cerca de 67@tie{}MiB ao usar um sistema de arquivos Btrfs compactado em zstd.}. Se você precisar apenas de alguns locais, poderá definir seu pacote de locais personalizados por meio do procedimento @code{make-glibc-utf8-locales} do módulo @code{(gnu packages base)}. O exemplo a seguir define um pacote contendo os vários locais UTF-8 canadenses conhecidos pela GNU@tie{}libc, que pesa cerca de 14@tie{}MiB:"

msgid ""
"(define my-glibc-locales\n"
"  (make-glibc-utf8-locales\n"
"   glibc\n"
"   #:locales (list \"en_CA\" \"fr_CA\" \"ik_CA\" \"iu_CA\" \"shs_CA\")\n"
"   #:name \"glibc-canadian-utf8-locales\"))\n"
msgstr ""
"(define my-glibc-locales\n"
"  (make-glibc-utf8-locales\n"
"   glibc\n"
"   #:locales (list \"en_CA\" \"fr_CA\" \"ik_CA\" \"iu_CA\" \"shs_CA\")\n"
"   #:name \"glibc-canadian-utf8-locales\"))\n"

msgid "The @env{GUIX_LOCPATH} variable plays a role similar to @env{LOCPATH} (@pxref{Locale Names, @env{LOCPATH},, libc, The GNU C Library Reference Manual}).  There are two important differences though:"
msgstr "A variável @env{GUIX_LOCPATH} desempenha um papel similar a @env{LOCPATH} (@pxref{Locale Names, @env{LOCPATH},, libc, The GNU C Library Reference Manual}). Há duas diferenças importantes, no entanto:"

msgid "@env{GUIX_LOCPATH} is honored only by the libc in Guix, and not by the libc provided by foreign distros.  Thus, using @env{GUIX_LOCPATH} allows you to make sure the programs of the foreign distro will not end up loading incompatible locale data."
msgstr "@env{GUIX_LOCPATH} é honrado apenas pela libc no Guix, e não pela libc fornecida por distros estrangeiras. Assim, usar @env{GUIX_LOCPATH} permite que você tenha certeza de que os programas da distro estrangeira não acabarão carregando dados de localidade incompatíveis."

msgid "libc suffixes each entry of @env{GUIX_LOCPATH} with @code{/X.Y}, where @code{X.Y} is the libc version---e.g., @code{2.22}.  This means that, should your Guix profile contain a mixture of programs linked against different libc version, each libc version will only try to load locale data in the right format."
msgstr "libc sufixa cada entrada de @env{GUIX_LOCPATH} com @code{/X.Y}, onde @code{X.Y} é a versão libc---por exemplo, @code{2.22}. Isso significa que, caso seu perfil Guix contenha uma mistura de programas vinculados a diferentes versões libc, cada versão libc tentará carregar apenas dados de localidade no formato correto."

msgid "This is important because the locale data format used by different libc versions may be incompatible."
msgstr "Isso é importante porque o formato de dados de localidade usado por diferentes versões da libc pode ser incompatível."

msgid "name service switch, glibc"
msgstr "troca de serviço de nome, glibc"

msgid "NSS (name service switch), glibc"
msgstr "NSS (troca de serviço de nomes), glibc"

msgid "When using Guix on a foreign distro, we @emph{strongly recommend} that the system run the GNU C library's @dfn{name service cache daemon}, @command{nscd}, which should be listening on the @file{/var/run/nscd/socket} socket.  Failing to do that, applications installed with Guix may fail to look up host names or user accounts, or may even crash.  The next paragraphs explain why."
msgstr "Ao usar o Guix em uma distro alheia, nós @emph{recomendamos fortemente} que o sistema use o @dfn{daemon de cache de serviço de nomes} da biblioteca C do GNU, @command{nscd}, que deve ouvir no soquete @file{/var/run/nscd/socket}. Caso não faça isso, os aplicativos instalados com Guix podem falhar em procurar nomes de máquina e contas de usuário, ou até mesmo travar. Os próximos parágrafos explicam o porquê."

msgid "nsswitch.conf"
msgstr "nsswitch.conf"

msgid "The GNU C library implements a @dfn{name service switch} (NSS), which is an extensible mechanism for ``name lookups'' in general: host name resolution, user accounts, and more (@pxref{Name Service Switch,,, libc, The GNU C Library Reference Manual})."
msgstr "A biblioteca GNU C implementa um @dfn{name service switch} (NSS), que é um mecanismo extensível para ``pesquisas de nomes'' em geral: resolução de nomes de host, contas de usuários e muito mais (@pxref{Name Service Switch,,, libc, The GNU C Library Reference Manual})."

msgid "Network information service (NIS)"
msgstr "Serviço de informação de rede (NIS)"

msgid "NIS (Network information service)"
msgstr "NIS (Serviço de informação de rede)"

msgid "Being extensible, the NSS supports @dfn{plugins}, which provide new name lookup implementations: for example, the @code{nss-mdns} plugin allow resolution of @code{.local} host names, the @code{nis} plugin allows user account lookup using the Network information service (NIS), and so on.  These extra ``lookup services'' are configured system-wide in @file{/etc/nsswitch.conf}, and all the programs running on the system honor those settings (@pxref{NSS Configuration File,,, libc, The GNU C Reference Manual})."
msgstr "Sendo extensível, o NSS suporta @dfn{plugins}, que fornecem novas implementações de pesquisa de nomes: por exemplo, o plugin @code{nss-mdns} permite a resolução de nomes de host @code{.local}, o plugin @code{nis} permite a pesquisa de contas de usuários usando o Network information service (NIS), e assim por diante. Esses \"serviços de pesquisa'' extras são configurados em todo o sistema em @file{/etc/nsswitch.conf}, e todos os programas em execução no sistema honram essas configurações (@pxref{NSS Configuration File,,, libc, The GNU C Reference Manual})."

msgid "When they perform a name lookup---for instance by calling the @code{getaddrinfo} function in C---applications first try to connect to the nscd; on success, nscd performs name lookups on their behalf.  If the nscd is not running, then they perform the name lookup by themselves, by loading the name lookup services into their own address space and running it.  These name lookup services---the @file{libnss_*.so} files---are @code{dlopen}'d, but they may come from the host system's C library, rather than from the C library the application is linked against (the C library coming from Guix)."
msgstr "Quando eles realizam uma pesquisa de nome --- por exemplo chamando a função @code{getaddrinfo} em C --- os aplicativos primeiro tentam se conectar ao nscd; em caso de sucesso, o nscd realiza pesquisas de nome em seu nome. Se o nscd não estiver em execução, eles realizam a pesquisa de nome sozinhos, carregando os serviços de pesquisa de nome em seu próprio espaço de endereço e executando-o. Esses serviços de pesquisa de nome --- os arquivos @file{libnss_*.so} --- são @code{dlopen}'d, mas podem vir da biblioteca C do sistema host, em vez da biblioteca C à qual o aplicativo está vinculado (a biblioteca C vem do Guix)."

msgid "And this is where the problem is: if your application is linked against Guix's C library (say, glibc 2.24) and tries to load NSS plugins from another C library (say, @code{libnss_mdns.so} for glibc 2.22), it will likely crash or have its name lookups fail unexpectedly."
msgstr "E é aqui que está o problema: se seu aplicativo estiver vinculado à biblioteca C do Guix (por exemplo, glibc 2.24) e tentar carregar plugins NSS de outra biblioteca C (por exemplo, @code{libnss_mdns.so} para glibc 2.22), ele provavelmente travará ou terá suas pesquisas de nome falhando inesperadamente."

msgid "Running @command{nscd} on the system, among other advantages, eliminates this binary incompatibility problem because those @code{libnss_*.so} files are loaded in the @command{nscd} process, not in applications themselves."
msgstr "Executar @command{nscd} no sistema, entre outras vantagens, elimina esse problema de incompatibilidade binária porque esses arquivos @code{libnss_*.so} são carregados no processo @command{nscd}, não nos próprios aplicativos."

msgid "X11 Fonts"
msgstr "Fontes X11"

msgid "The majority of graphical applications use Fontconfig to locate and load fonts and perform X11-client-side rendering.  The @code{fontconfig} package in Guix looks for fonts in @file{$HOME/.guix-profile} by default.  Thus, to allow graphical applications installed with Guix to display fonts, you have to install fonts with Guix as well.  Essential font packages include @code{font-ghostscript}, @code{font-dejavu}, and @code{font-gnu-freefont}."
msgstr "A maioria dos aplicativos gráficos usa o Fontconfig para localizar e carregar fontes e executar renderização do lado do cliente X11. O pacote @code{fontconfig} no Guix procura fontes em @file{$HOME/.guix-profile} por padrão. Assim, para permitir que aplicativos gráficos instalados com o Guix exibam fontes, você precisa instalar fontes com o Guix também. Pacotes de fontes essenciais incluem @code{font-ghostscript}, @code{font-dejavu} e @code{font-gnu-freefont}."

msgid "fc-cache"
msgstr "fc-cache"

msgid "font cache"
msgstr "cache de font"

msgid "Once you have installed or removed fonts, or when you notice an application that does not find fonts, you may need to install Fontconfig and to force an update of its font cache by running:"
msgstr "Depois de instalar ou remover fontes, ou quando notar que um aplicativo não encontra fontes, talvez seja necessário instalar o Fontconfig e forçar uma atualização do cache de fontes executando:"

msgid ""
"guix install fontconfig\n"
"fc-cache -rv\n"
msgstr ""
"guix install fontconfig\n"
"fc-cache -rv\n"

msgid "To display text written in Chinese languages, Japanese, or Korean in graphical applications, consider installing @code{font-adobe-source-han-sans} or @code{font-wqy-zenhei}.  The former has multiple outputs, one per language family (@pxref{Packages with Multiple Outputs}).  For instance, the following command installs fonts for Chinese languages:"
msgstr "Para exibir texto escrito em chinês, japonês ou coreano em aplicativos gráficos, considere instalar @code{font-adobe-source-han-sans} ou @code{font-wqy-zenhei}. O primeiro tem várias saídas, uma por família de idiomas (@pxref{Packages with Multiple Outputs}). Por exemplo, o comando a seguir instala fontes para idiomas chineses:"

msgid "guix install font-adobe-source-han-sans:cn\n"
msgstr "guix install font-adobe-source-han-sans:cn\n"

msgid "xterm"
msgstr "xterm"

msgid "Older programs such as @command{xterm} do not use Fontconfig and instead rely on server-side font rendering.  Such programs require to specify a full name of a font using XLFD (X Logical Font Description), like this:"
msgstr "Programas mais antigos como @command{xterm} não usam Fontconfig e, em vez disso, dependem da renderização de fontes do lado do servidor. Tais programas exigem a especificação de um nome completo de uma fonte usando XLFD (X Logical Font Description), como este:"

msgid "-*-dejavu sans-medium-r-normal-*-*-100-*-*-*-*-*-1\n"
msgstr "-*-dejavu sans-medium-r-normal-*-*-100-*-*-*-*-*-1\n"

msgid "To be able to use such full names for the TrueType fonts installed in your Guix profile, you need to extend the font path of the X server:"
msgstr "Para poder usar esses nomes completos para as fontes TrueType instaladas no seu perfil Guix, você precisa estender o caminho da fonte do servidor X:"

msgid "xset +fp $(dirname $(readlink -f ~/.guix-profile/share/fonts/truetype/fonts.dir))\n"
msgstr "xset +fp $(dirname $(readlink -f ~/.guix-profile/share/fonts/truetype/fonts.dir))\n"

msgid "xlsfonts"
msgstr "xlsfonts"

msgid "After that, you can run @code{xlsfonts} (from @code{xlsfonts} package)  to make sure your TrueType fonts are listed there."
msgstr "Depois disso, você pode executar @code{xlsfonts} (do pacote @code{xlsfonts}) para garantir que suas fontes TrueType estejam listadas lá."

msgid "nss-certs"
msgstr "nss-certs"

msgid "The @code{nss-certs} package provides X.509 certificates, which allow programs to authenticate Web servers accessed over HTTPS."
msgstr "O pacote @code{nss-certs} fornece certificados X.509, que permitem que programas autentiquem servidores Web acessados por HTTPS."

msgid "When using Guix on a foreign distro, you can install this package and define the relevant environment variables so that packages know where to look for certificates.  @xref{X.509 Certificates}, for detailed information."
msgstr "Ao usar uma Guix em uma distro alheia, você pode instalar esse pacote e definir as variáveis de ambiente relevantes de forma que os pacotes saibam onde procurar por certificados. @xref{X.509 Certificates}, para informações detalhadas."

msgid "emacs"
msgstr "emacs"

msgid "When you install Emacs packages with Guix, the Elisp files are placed under the @file{share/emacs/site-lisp/} directory of the profile in which they are installed.  The Elisp libraries are made available to Emacs through the @env{EMACSLOADPATH} environment variable, which is set when installing Emacs itself."
msgstr "Quando você instala pacotes do Emacs com o Guix, os arquivos Elisp são colocados no diretório @file{share/emacs/site-lisp/} do perfil no qual eles são instalados. As bibliotecas Elisp são disponibilizadas para o Emacs por meio da variável de ambiente @env{EMACSLOADPATH}, que é definida ao instalar o próprio Emacs."

msgid "guix-emacs-autoload-packages, refreshing Emacs packages"
msgstr "guix-emacs-autoload-packages, atualizando pacotes Emacs"

msgid "Additionally, autoload definitions are automatically evaluated at the initialization of Emacs, by the Guix-specific @code{guix-emacs-autoload-packages} procedure.  This procedure can be interactively invoked to have newly installed Emacs packages discovered, without having to restart Emacs.  If, for some reason, you want to avoid auto-loading the Emacs packages installed with Guix, you can do so by running Emacs with the @option{--no-site-file} option (@pxref{Init File,,, emacs, The GNU Emacs Manual})."
msgstr "Além disso, as definições de autoload são avaliadas automaticamente na inicialização do Emacs, pelo procedimento específico do Guix @code{guix-emacs-autoload-packages}. Este procedimento pode ser invocado interativamente para que pacotes Emacs recém-instalados sejam descobertos, sem precisar reiniciar o Emacs. Se, por algum motivo, você quiser evitar o carregamento automático dos pacotes Emacs instalados com o Guix, você pode fazer isso executando o Emacs com a opção @option{--no-site-file} (@pxref{Init File,,, emacs, The GNU Emacs Manual})."

msgid "Most Emacs variants are now capable of doing native compilation.  The approach taken by Guix Emacs however differs greatly from the approach taken upstream."
msgstr "A maioria das variantes do Emacs agora são capazes de fazer compilação nativa. A abordagem adotada pelo Guix Emacs, no entanto, difere muito da abordagem adotada pelo upstream."

msgid "Upstream Emacs compiles packages just-in-time and typically places shared object files in a special folder within your @code{user-emacs-directory}.  These shared objects within said folder are organized in a flat hierarchy, and their file names contain two hashes to verify the original file name and contents of the source code."
msgstr "O Upstream Emacs compila pacotes just-in-time e normalmente coloca arquivos de objetos compartilhados em uma pasta especial dentro do seu @code{user-emacs-directory}. Esses objetos compartilhados dentro da referida pasta são organizados em uma hierarquia plana, e seus nomes de arquivo contêm dois hashes para verificar o nome do arquivo original e o conteúdo do código-fonte."

msgid "Guix Emacs on the other hand prefers to compile packages ahead-of-time.  Shared objects retain much of the original file name and no hashes are added to verify the original file name or the contents of the file.  Crucially, this allows Guix Emacs and packages built against it to be grafted (@pxref{Security Updates, grafts}), but at the same time, Guix Emacs lacks the hash-based verification of source code baked into upstream Emacs.  As this naming schema is trivial to exploit, we disable just-in-time compilation."
msgstr "O Guix Emacs, por outro lado, prefere compilar pacotes antes do tempo. Objetos compartilhados retêm muito do nome do arquivo original e nenhum hashe é adicionado para verificar o nome do arquivo original ou o conteúdo do arquivo. Crucialmente, isso permite que o Guix Emacs e os pacotes construídos contra ele sejam enxertados (@pxref{Security Updates, enxertos}), mas, ao mesmo tempo, o Guix Emacs não tem a verificação baseada em hash do código-fonte embutido no Emacs upstream. Como esse esquema de nomenclatura é trivial de explorar, desabilitamos a compilação just-in-time."

msgid "Further note, that @code{emacs-minimal}---the default Emacs for building packages---has been configured without native compilation.  To natively compile your emacs packages ahead of time, use a transformation like @option{--with-input=emacs-minimal=emacs}."
msgstr "Observe ainda que @code{emacs-minimal}---o Emacs padrão para construir pacotes---foi configurado sem compilação nativa. Para compilar nativamente seus pacotes emacs antes do tempo, use uma transformação como @option{--with-input=emacs-minimal=emacs}."

msgid "Upgrading Guix, on a foreign distro"
msgstr "Atualizando o Guix, em uma distribuição estrangeira"

msgid "To upgrade Guix, run:"
msgstr "Para atualizar o Guix, execute:"

msgid "guix pull\n"
msgstr "guix pull\n"

msgid "@xref{Invoking guix pull}, for more information."
msgstr "@xref{Invoking guix pull}, para maiores informações."

msgid "upgrading Guix for the root user, on a foreign distro"
msgstr "atualizando Guix para o usuário root, em uma distribuição estrangeira"

msgid "upgrading the Guix daemon, on a foreign distro"
msgstr "atualizando o daemon Guix, em uma distribuição estrangeira"

msgid "@command{guix pull} for the root user, on a foreign distro"
msgstr "@command{guix pull} para o usuário root, em uma distribuição estrangeira"

msgid "sudo -i guix pull\n"
msgstr "sudo -i guix pull\n"

msgid "followed by (assuming your distro uses the systemd service management tool):"
msgstr "seguido por (supondo que sua distribuição use a ferramenta de gerenciamento de serviço systemd):"

msgid "systemctl restart guix-daemon.service\n"
msgstr "systemctl restart guix-daemon.service\n"

msgid "On Guix System, upgrading the daemon is achieved by reconfiguring the system (@pxref{Invoking guix system, @code{guix system reconfigure}})."
msgstr "No sistema Guix, a atualização do daemon é obtida reconfigurando o sistema (@pxref{Invoking guix system, @code{guix system reconfigure}})."

msgid "installing Guix System"
msgstr "instalando o Guix System"

msgid "Guix System, installation"
msgstr "Guix System, instalação"

msgid "This section explains how to install Guix System on a machine.  Guix, as a package manager, can also be installed on top of a running GNU/Linux system, @pxref{Installation}."
msgstr "Esta seção explica como instalar o Guix System em uma máquina. Guix, como gerenciador de pacotes, também pode ser instalado sobre um sistema GNU/Linux em execução, @pxref{Installation}."

msgid "You are reading this documentation with an Info reader.  For details on how to use it, hit the @key{RET} key (``return'' or ``enter'') on the link that follows: @pxref{Top, Info reader,, info-stnd, Stand-alone GNU Info}.  Hit @kbd{l} afterwards to come back here."
msgstr "Você está lendo esta documentação com um leitor de informações. Para obter detalhes sobre como usá-lo, pressione a tecla @key{RET} (\"return'' ou  \"enter'') no link a seguir: @pxref{Top, Info reader,, info-stnd, Stand-alone GNU Info}. Clique em @kbd{l} depois para voltar aqui."

msgid "Alternatively, run @command{info info} in another tty to keep the manual available."
msgstr "Alternativamente, execute @command{info info} em outro tty para manter o manual disponível."

msgid "We consider Guix System to be ready for a wide range of ``desktop'' and server use cases.  The reliability guarantees it provides---transactional upgrades and rollbacks, reproducibility---make it a solid foundation."
msgstr "Consideramos que o Guix System está pronto para uma ampla gama de casos de uso de \"desktop'' e servidores. As garantias de confiabilidade que ele fornece – atualizações e reversões transacionais, reprodutibilidade – tornam-no uma base sólida."

msgid "More and more system services are provided (@pxref{Services})."
msgstr "Cada vez mais serviços de sistema são fornecidos (@pxref{Services})."

msgid "Nevertheless, before you proceed with the installation, be aware that some services you rely on may still be missing from version @value{VERSION}."
msgstr "No entanto, antes de prosseguir com a instalação, esteja ciente de que alguns serviços dos quais você depende ainda podem estar faltando na versão @value{VERSION}."

msgid "More than a disclaimer, this is an invitation to report issues (and success stories!), and to join us in improving it.  @xref{Contributing}, for more info."
msgstr "Mais do que um aviso de isenção de responsabilidade, este é um convite para relatar problemas (e histórias de sucesso!) e se juntar a nós para melhorá-los. @xref{Contributing}, para mais informações."

msgid "hardware support on Guix System"
msgstr "suporte a hardware no Guix System"

msgid "GNU@tie{}Guix focuses on respecting the user's computing freedom.  It builds around the kernel Linux-libre, which means that only hardware for which free software drivers and firmware exist is supported.  Nowadays, a wide range of off-the-shelf hardware is supported on GNU/Linux-libre---from keyboards to graphics cards to scanners and Ethernet controllers.  Unfortunately, there are still areas where hardware vendors deny users control over their own computing, and such hardware is not supported on Guix System."
msgstr "GNU@tie{}Guix se concentra em respeitar a liberdade computacional do usuário. Ele é construído em torno do kernel Linux-libre, o que significa que apenas o hardware para o qual existem drivers e firmware de software livre é suportado. Hoje em dia, uma ampla gama de hardware disponível no mercado é suportada no GNU/Linux-libre – de teclados a placas gráficas, scanners e controladores Ethernet. Infelizmente, ainda existem áreas onde os fornecedores de hardware negam aos usuários o controle sobre sua própria computação, e tal hardware não é suportado no Guix System."

msgid "WiFi, hardware support"
msgstr "Wi-Fi, suporte de hardware"

msgid "One of the main areas where free drivers or firmware are lacking is WiFi devices.  WiFi devices known to work include those using Atheros chips (AR9271 and AR7010), which corresponds to the @code{ath9k} Linux-libre driver, and those using Broadcom/AirForce chips (BCM43xx with Wireless-Core Revision 5), which corresponds to the @code{b43-open} Linux-libre driver.  Free firmware exists for both and is available out-of-the-box on Guix System, as part of @code{%base-firmware} (@pxref{operating-system Reference, @code{firmware}})."
msgstr "Uma das principais áreas onde faltam drivers ou firmware gratuitos são os dispositivos WiFi. Os dispositivos WiFi que funcionam incluem aqueles que usam chips Atheros (AR9271 e AR7010), que corresponde ao driver @code{ath9k} Linux-libre, e aqueles que usam chips Broadcom/AirForce (BCM43xx com Wireless-Core Revisão 5), que corresponde a o driver livre Linux @code{b43-open}. Existe firmware livre para ambos e está disponível imediatamente no Guix System, como parte do @code{%base-firmware} (@pxref{operating-system Reference, @code{firmware}})."

msgid "The installer warns you early on if it detects devices that are known @emph{not} to work due to the lack of free firmware or free drivers."
msgstr "O instalador avisa você antecipadamente se detectar dispositivos que @emph{não} funcionam devido à falta de firmware ou drivers gratuitos."

msgid "RYF, Respects Your Freedom"
msgstr "RYF, respeita sua liberdade"

msgid "The @uref{https://www.fsf.org/, Free Software Foundation} runs @uref{https://www.fsf.org/ryf, @dfn{Respects Your Freedom}} (RYF), a certification program for hardware products that respect your freedom and your privacy and ensure that you have control over your device.  We encourage you to check the list of RYF-certified devices."
msgstr "A @uref{https://www.fsf.org/, Free Software Foundation} administra @uref{https://www.fsf.org/ryf, @dfn{Respects Your Freedom}} (RYF), um programa de certificação para produtos de hardware que respeitem sua liberdade e privacidade e garantam que você tenha controle sobre seu dispositivo. Recomendamos que você verifique a lista de dispositivos certificados RYF."

msgid "Another useful resource is the @uref{https://www.h-node.org/, H-Node} web site.  It contains a catalog of hardware devices with information about their support in GNU/Linux."
msgstr "Outro recurso útil é o site @uref{https://www.h-node.org/, H-Node}. Ele contém um catálogo de dispositivos de hardware com informações sobre seu suporte no GNU/Linux."

msgid "An ISO-9660 installation image that can be written to a USB stick or burnt to a DVD can be downloaded from @indicateurl{@value{BASE-URL}/guix-system-install-@value{VERSION}.x86_64-linux.iso}, where you can replace @code{x86_64-linux} with one of:"
msgstr "Uma imagem de instalação ISO-9660 que pode ser gravada em um pendrive ou gravada em um DVD pode ser baixada em @indicateurl{@value{BASE-URL}/guix-system-install-@value{VERSION}.x86_64-linux.iso}, onde você pode substituir @code{x86_64-linux} por um dos seguintes:"

msgid "for a GNU/Linux system on Intel/AMD-compatible 64-bit CPUs;"
msgstr "para um sistema GNU/Linux em CPUs de 64 bits compatíveis com Intel/AMD;"

msgid "for a 32-bit GNU/Linux system on Intel-compatible CPUs."
msgstr "para um sistema GNU/Linux de 32 bits em CPUs compatíveis com Intel."

msgid "Make sure to download the associated @file{.sig} file and to verify the authenticity of the image against it, along these lines:"
msgstr "Certifique-se de baixar o arquivo @file{.sig} associado e verificar a autenticidade da imagem em relação a ele, seguindo estas linhas:"

msgid ""
"$ wget @value{BASE-URL}/guix-system-install-@value{VERSION}.x86_64-linux.iso.sig\n"
"$ gpg --verify guix-system-install-@value{VERSION}.x86_64-linux.iso.sig\n"
msgstr ""
"$ wget @value{BASE-URL}/guix-system-install-@value{VERSION}.x86_64-linux.iso.sig\n"
"$ gpg --verify guix-system-install-@value{VERSION}.x86_64-linux.iso.sig\n"

msgid "If that command fails because you do not have the required public key, then run this command to import it:"
msgstr "Se esse comando falhar porque você não possui a chave pública requerida, execute este comando para importá-lo:"

msgid ""
"$ wget @value{OPENPGP-SIGNING-KEY-URL} \\\n"
"      -qO - | gpg --import -\n"
msgstr ""
"$ wget @value{OPENPGP-SIGNING-KEY-URL} \\\n"
"      -qO - | gpg --import -\n"

msgid "and rerun the @code{gpg --verify} command."
msgstr "e execute novamente o comando @code{gpg --verify}."

msgid "Take note that a warning like ``This key is not certified with a trusted signature!'' is normal."
msgstr "Observe que um aviso como \"Esta chave não está certificada com uma assinatura confiável!'' é normal."

msgid "This image contains the tools necessary for an installation.  It is meant to be copied @emph{as is} to a large-enough USB stick or DVD."
msgstr "Esta imagem contém as ferramentas necessárias para uma instalação. Ele deve ser copiado @emph{como está} para um pendrive ou DVD grande o suficiente."

msgid "Copying to a USB Stick"
msgstr "Copiando para um pendrive"

msgid "Insert a USB stick of 1@tie{}GiB or more into your machine, and determine its device name.  Assuming that the USB stick is known as @file{/dev/sdX}, copy the image with:"
msgstr "Insira um pendrive de 1@tie{}GiB ou mais em sua máquina e determine o nome do dispositivo. Supondo que o pendrive seja conhecido como @file{/dev/sdX}, copie a imagem com:"

msgid ""
"dd if=guix-system-install-@value{VERSION}.x86_64-linux.iso of=/dev/sdX status=progress\n"
"sync\n"
msgstr ""
"dd if=guix-system-install-@value{VERSION}.x86_64-linux.iso of=/dev/sdX status=progress\n"
"sync\n"

msgid "Access to @file{/dev/sdX} usually requires root privileges."
msgstr "O acesso a @file{/dev/sdX} geralmente requer privilégios de root."

msgid "Burning on a DVD"
msgstr "Gravando em um DVD"

msgid "Insert a blank DVD into your machine, and determine its device name.  Assuming that the DVD drive is known as @file{/dev/srX}, copy the image with:"
msgstr "Insira um DVD virgem em sua máquina e determine o nome do dispositivo. Supondo que a unidade de DVD seja conhecida como @file{/dev/srX}, copie a imagem com:"

msgid "growisofs -dvd-compat -Z /dev/srX=guix-system-install-@value{VERSION}.x86_64-linux.iso\n"
msgstr "growisofs -dvd-compat -Z /dev/srX=guix-system-install-@value{VERSION}.x86_64-linux.iso\n"

msgid "Access to @file{/dev/srX} usually requires root privileges."
msgstr "O acesso a @file{/dev/srX} geralmente requer privilégios de root."

msgid "Booting"
msgstr "Inicializando"

msgid "Once this is done, you should be able to reboot the system and boot from the USB stick or DVD@.  The latter usually requires you to get in the BIOS or UEFI boot menu, where you can choose to boot from the USB stick.  In order to boot from Libreboot, switch to the command mode by pressing the @kbd{c} key and type @command{search_grub usb}."
msgstr "Feito isso, você poderá reiniciar o sistema e inicializar a partir do pendrive ou DVD@. O último geralmente requer que você entre no menu de inicialização do BIOS ou UEFI, onde você pode optar por inicializar a partir do pendrive. Para inicializar a partir do Libreboot, mude para o modo de comando pressionando a tecla @kbd{c} e digite @command{search_grub usb}."

msgid "Sadly, on some machines, the installation medium cannot be properly booted and you only see a black screen after booting even after you waited for ten minutes.  This may indicate that your machine cannot run Guix System; perhaps you instead want to install Guix on a foreign distro (@pxref{Binary Installation}).  But don't give up just yet; a possible workaround is pressing the @kbd{e} key in the GRUB boot menu and appending @option{nomodeset} to the Linux bootline.  Sometimes the black screen issue can also be resolved by connecting a different display."
msgstr "Infelizmente, em algumas máquinas, o meio de instalação não pode ser inicializado corretamente e você só verá uma tela preta após a inicialização, mesmo depois de esperar dez minutos. Isto pode indicar que sua máquina não consegue executar o Sistema Guix; talvez você queira instalar o Guix em uma distribuição estrangeira (@pxref{Binary Installation}). Mas não desista ainda; uma possível solução alternativa é pressionar a tecla @kbd{e} no menu de inicialização do GRUB e anexar @option{nomodeset} à linha de inicialização do Linux. Às vezes, o problema da tela preta também pode ser resolvido conectando um monitor diferente."

msgid "@xref{Installing Guix in a VM}, if, instead, you would like to install Guix System in a virtual machine (VM)."
msgstr "@xref{Installing Guix in a VM}, se, em vez disso, você quiser instalar o Guix System em uma máquina virtual (VM)."

msgid "Once you have booted, you can use the guided graphical installer, which makes it easy to get started (@pxref{Guided Graphical Installation}).  Alternatively, if you are already familiar with GNU/Linux and if you want more control than what the graphical installer provides, you can choose the ``manual'' installation process (@pxref{Manual Installation})."
msgstr "Depois de inicializar, você pode usar o instalador gráfico guiado, o que facilita o início (@pxref{Guided Graphical Installation}). Alternativamente, se você já está familiarizado com GNU/Linux e deseja mais controle do que o instalador gráfico oferece, você pode escolher o processo de instalação \"manual'' (@pxref{Manual Installation})."

msgid "The graphical installer is available on TTY1.  You can obtain root shells on TTYs 3 to 6 by hitting @kbd{ctrl-alt-f3}, @kbd{ctrl-alt-f4}, etc.  TTY2 shows this documentation and you can reach it with @kbd{ctrl-alt-f2}.  Documentation is browsable using the Info reader commands (@pxref{Top,,, info-stnd, Stand-alone GNU Info}).  The installation system runs the GPM mouse daemon, which allows you to select text with the left mouse button and to paste it with the middle button."
msgstr "O instalador gráfico está disponível em TTY1. Você pode obter shells root em TTYs 3 a 6 pressionando @kbd{ctrl-alt-f3}, @kbd{ctrl-alt-f4}, etc. TTY2 mostra esta documentação e você pode acessá-la com @kbd{ctrl-alt -f2}. A documentação pode ser navegada usando os comandos do leitor de informações (@pxref{Top,,, info-stnd, Stand-alone GNU Info}). O sistema de instalação executa o daemon do mouse GPM, que permite selecionar texto com o botão esquerdo do mouse e colá-lo com o botão do meio."

msgid "Installation requires access to the Internet so that any missing dependencies of your system configuration can be downloaded.  See the ``Networking'' section below."
msgstr "A instalação requer acesso à Internet para que quaisquer dependências ausentes na configuração do sistema possam ser baixadas. Consulte a seção \"Rede\" abaixo."

msgid "The graphical installer is a text-based user interface.  It will guide you, with dialog boxes, through the steps needed to install GNU@tie{}Guix System."
msgstr "O instalador gráfico é uma interface de usuário baseada em texto. Ele guiará você, com caixas de diálogo, pelas etapas necessárias para instalar o GNU@tie{}Guix System."

msgid "The first dialog boxes allow you to set up the system as you use it during the installation: you can choose the language, keyboard layout, and set up networking, which will be used during the installation.  The image below shows the networking dialog."
msgstr "As primeiras caixas de diálogo permitem que você configure o sistema conforme você o utiliza durante a instalação: você pode escolher o idioma, o layout do teclado e configurar a rede que será usada durante a instalação. A imagem abaixo mostra a caixa de diálogo de rede."

msgid "@image{images/installer-network,5in,, networking setup with the graphical installer}"
msgstr "@image{images/installer-network,5in,, configuração de rede com o instalador gráfico}"

msgid "Later steps allow you to partition your hard disk, as shown in the image below, to choose whether or not to use encrypted file systems, to enter the host name and root password, and to create an additional account, among other things."
msgstr "As etapas posteriores permitem particionar seu disco rígido, conforme mostrado na imagem abaixo, escolher se deseja ou não usar sistemas de arquivos criptografados, inserir o nome do host e a senha root e criar uma conta adicional, entre outras coisas."

msgid "@image{images/installer-partitions,5in,, partitioning with the graphical installer}"
msgstr "@image{images/installer-partitions,5in,, particionando com o instalador gráfico}"

msgid "Note that, at any time, the installer allows you to exit the current installation step and resume at a previous step, as show in the image below."
msgstr "Observe que, a qualquer momento, o instalador permite sair da etapa de instalação atual e retomar uma etapa anterior, conforme imagem abaixo."

msgid "@image{images/installer-resume,5in,, resuming the installation process}"
msgstr "@image{images/installer-resume,5in,, retomando o processo de instalação}"

msgid "Once you're done, the installer produces an operating system configuration and displays it (@pxref{Using the Configuration System}).  At that point you can hit ``OK'' and installation will proceed.  On success, you can reboot into the new system and enjoy.  @xref{After System Installation}, for what's next!"
msgstr "Quando terminar, o instalador produz uma configuração do sistema operacional e a exibe (@pxref{Using the Configuration System}). Nesse ponto você pode clicar em \"OK'' e a instalação continuará. Se tiver sucesso, você pode reiniciar no novo sistema e aproveitar. @xref{After System Installation}, para saber o que vem a seguir!"

msgid "This section describes how you would ``manually'' install GNU@tie{}Guix System on your machine.  This option requires familiarity with GNU/Linux, with the shell, and with common administration tools.  If you think this is not for you, consider using the guided graphical installer (@pxref{Guided Graphical Installation})."
msgstr "Esta seção descreve como você instalaria \"manualmente'' o GNU@tie{}Guix System em sua máquina. Esta opção requer familiaridade com GNU/Linux, com o shell e com ferramentas de administração comuns. Se você acha que isso não é para você, considere usar o instalador gráfico guiado (@pxref{Guided Graphical Installation})."

msgid "The installation system provides root shells on TTYs 3 to 6; press @kbd{ctrl-alt-f3}, @kbd{ctrl-alt-f4}, and so on to reach them.  It includes many common tools needed to install the system, but is also a full-blown Guix System.  This means that you can install additional packages, should you need it, using @command{guix package} (@pxref{Invoking guix package})."
msgstr "O sistema de instalação fornece shells root nos TTYs 3 a 6; pressione @kbd{ctrl-alt-f3}, @kbd{ctrl-alt-f4} e assim por diante para alcançá-los. Inclui muitas ferramentas comuns necessárias para instalar o sistema, mas também é um sistema Guix completo. Isso significa que você pode instalar pacotes adicionais, caso precise, usando @command{guix package} (@pxref{Invoking guix package})."

msgid "Keyboard Layout, Networking, and Partitioning"
msgstr "Layout de teclado, rede e particionamento"

msgid "Before you can install the system, you may want to adjust the keyboard layout, set up networking, and partition your target hard disk.  This section will guide you through this."
msgstr "Antes de instalar o sistema, você pode querer ajustar o layout do teclado, configurar a rede e particionar o disco rígido de destino. Esta seção irá guiá-lo através disso."

msgid "keyboard layout"
msgstr "disposição do teclado"

msgid "The installation image uses the US qwerty keyboard layout.  If you want to change it, you can use the @command{loadkeys} command.  For example, the following command selects the Dvorak keyboard layout:"
msgstr "A imagem de instalação usa o layout de teclado qwerty dos EUA. Se quiser alterá-lo, você pode usar o comando @command{loadkeys}. Por exemplo, o comando a seguir seleciona o layout do teclado Dvorak:"

msgid "loadkeys dvorak\n"
msgstr "loadkeys dvorak\n"

msgid "See the files under @file{/run/current-system/profile/share/keymaps} for a list of available keyboard layouts.  Run @command{man loadkeys} for more information."
msgstr "Consulte os arquivos em @file{/run/current-system/profile/share/keymaps} para obter uma lista de layouts de teclado disponíveis. Execute @command{man loadkeys} para obter mais informações."

msgid "manual-installation-networking"
msgstr "manual-installation-networking"

msgid "Networking"
msgstr "Rede"

msgid "Run the following command to see what your network interfaces are called:"
msgstr "Execute o seguinte comando para ver como são chamadas suas interfaces de rede:"

msgid "ifconfig -a\n"
msgstr "ifconfig -a\n"

msgid "@dots{} or, using the GNU/Linux-specific @command{ip} command:"
msgstr "@dots{} ou, usando o comando @command{ip} específico do GNU/Linux:"

msgid "ip address\n"
msgstr "ip address\n"

msgid "Wired interfaces have a name starting with @samp{e}; for example, the interface corresponding to the first on-board Ethernet controller is called @samp{eno1}.  Wireless interfaces have a name starting with @samp{w}, like @samp{w1p2s0}."
msgstr "As interfaces com fio têm um nome que começa com @samp{e}; por exemplo, a interface correspondente ao primeiro controlador Ethernet integrado é chamada @samp{eno1}. As interfaces sem fio têm um nome que começa com @samp{w}, como @samp{w1p2s0}."

msgid "Wired connection"
msgstr "Conexão cabeada"

msgid "To configure a wired network run the following command, substituting @var{interface} with the name of the wired interface you want to use."
msgstr "Para configurar uma rede com fio execute o seguinte comando, substituindo @var{interface} pelo nome da interface com fio que você deseja usar."

msgid "ifconfig @var{interface} up\n"
msgstr "ifconfig @var{interface} up\n"

msgid "Wireless connection"
msgstr "Conexão sem fio"

msgid "wireless"
msgstr "sem fio"

msgid "WiFi"
msgstr "WiFi"

msgid "To configure wireless networking, you can create a configuration file for the @command{wpa_supplicant} configuration tool (its location is not important) using one of the available text editors such as @command{nano}:"
msgstr "Para configurar a rede sem fio, você pode criar um arquivo de configuração para a ferramenta de configuração @command{wpa_supplicant} (sua localização não é importante) usando um dos editores de texto disponíveis, como @command{nano}:"

msgid "nano wpa_supplicant.conf\n"
msgstr "nano wpa_supplicant.conf\n"

msgid "As an example, the following stanza can go to this file and will work for many wireless networks, provided you give the actual SSID and passphrase for the network you are connecting to:"
msgstr "Como exemplo, a sub-rotina a seguir pode ir para este arquivo e funcionará para muitas redes sem fio, desde que você forneça o SSID e a senha reais da rede à qual está se conectando:"

msgid ""
"network=@{\n"
"  ssid=\"@var{my-ssid}\"\n"
"  key_mgmt=WPA-PSK\n"
"  psk=\"the network's secret passphrase\"\n"
"@}\n"
msgstr ""
"network=@{\n"
"  ssid=\"@var{my-ssid}\"\n"
"  key_mgmt=WPA-PSK\n"
"  psk=\"the network's secret passphrase\"\n"
"@}\n"

msgid "Start the wireless service and run it in the background with the following command (substitute @var{interface} with the name of the network interface you want to use):"
msgstr "Inicie o serviço sem fio e execute-o em segundo plano com o seguinte comando (substitua @var{interface} pelo nome da interface de rede que deseja usar):"

msgid "wpa_supplicant -c wpa_supplicant.conf -i @var{interface} -B\n"
msgstr "wpa_supplicant -c wpa_supplicant.conf -i @var{interface} -B\n"

msgid "Run @command{man wpa_supplicant} for more information."
msgstr "Execute @command{man wpa_supplicant} para obter mais informações."

msgid "DHCP"
msgstr "DHCP"

msgid "At this point, you need to acquire an IP address.  On a network where IP addresses are automatically assigned @i{via} DHCP, you can run:"
msgstr "Neste ponto, você precisa adquirir um endereço IP. Em uma rede onde os endereços IP são atribuídos automaticamente @i{via} DHCP, você pode executar:"

msgid "dhclient -v @var{interface}\n"
msgstr "dhclient -v @var{interface}\n"

msgid "Try to ping a server to see if networking is up and running:"
msgstr "Tente executar ping em um servidor para ver se a rede está funcionando:"

msgid "ping -c 3 gnu.org\n"
msgstr "ping -c 3 gnu.org\n"

msgid "Setting up network access is almost always a requirement because the image does not contain all the software and tools that may be needed."
msgstr "Configurar o acesso à rede é quase sempre um requisito porque a imagem não contém todos os softwares e ferramentas que podem ser necessários."

msgid "proxy, during system installation"
msgstr "proxy, durante a instalação do sistema"

msgid "If you need HTTP and HTTPS access to go through a proxy, run the following command:"
msgstr "Se você precisar de acesso HTTP e HTTPS para passar por um proxy, execute o seguinte comando:"

msgid "herd set-http-proxy guix-daemon @var{URL}\n"
msgstr "herd set-http-proxy guix-daemon @var{URL}\n"

msgid "where @var{URL} is the proxy URL, for example @code{http://example.org:8118}."
msgstr "onde @var{URL} é a URL do proxy, por exemplo @code{http://example.org:8118}."

msgid "installing over SSH"
msgstr "instalando via SSH"

msgid "If you want to, you can continue the installation remotely by starting an SSH server:"
msgstr "Se desejar, você pode continuar a instalação remotamente iniciando um servidor SSH:"

msgid "herd start ssh-daemon\n"
msgstr "herd start ssh-daemon\n"

msgid "Make sure to either set a password with @command{passwd}, or configure OpenSSH public key authentication before logging in."
msgstr "Certifique-se de definir uma senha com @command{passwd} ou configurar a autenticação de chave pública OpenSSH antes de efetuar login."

msgid "Disk Partitioning"
msgstr "Particionamento de disco"

msgid "Unless this has already been done, the next step is to partition, and then format the target partition(s)."
msgstr "A menos que isso já tenha sido feito, o próximo passo é particionar e então formatar a(s) partição(ões) de destino."

msgid "The installation image includes several partitioning tools, including Parted (@pxref{Overview,,, parted, GNU Parted User Manual}), @command{fdisk}, and @command{cfdisk}.  Run it and set up your disk with the partition layout you want:"
msgstr "A imagem de instalação inclui várias ferramentas de particionamento, incluindo Parted (@pxref{Overview,,, parted, GNU Parted User Manual}), @command{fdisk} e @command{cfdisk}. Execute-a e configure seu disco com o layout de partição que você deseja:"

msgid "cfdisk\n"
msgstr "cfdisk\n"

msgid "If your disk uses the GUID Partition Table (GPT) format and you plan to install BIOS-based GRUB (which is the default), make sure a BIOS Boot Partition is available (@pxref{BIOS installation,,, grub, GNU GRUB manual})."
msgstr "Se o seu disco usa o formato GUID Partition Table (GPT) e você planeja instalar o GRUB baseado em BIOS (que é o padrão), certifique-se de que uma partição de inicialização do BIOS esteja disponível (@pxref{BIOS installation,,, grub, manual do GNU GRUB})."

msgid "EFI, installation"
msgstr "EFI, instalação"

msgid "UEFI, installation"
msgstr "UEFI, instalação"

msgid "ESP, EFI system partition"
msgstr "ESP, partição do sistema EFI"

msgid "If you instead wish to use EFI-based GRUB, a FAT32 @dfn{EFI System Partition} (ESP) is required.  This partition can be mounted at @file{/boot/efi} for instance and must have the @code{esp} flag set.  E.g., for @command{parted}:"
msgstr "Se você preferir usar o GRUB baseado em EFI, uma partição de sistema EFI (ESP) FAT32 @dfn{EFI System Partition} é necessária. Essa partição pode ser montada em @file{/boot/efi}, por exemplo, e deve ter o sinalizador @code{esp} definido. Por exemplo, para @command{parted}:"

msgid "parted /dev/sda set 1 esp on\n"
msgstr "parted /dev/sda set 1 esp on\n"

msgid "grub-bootloader"
msgstr "grub-bootloader"

msgid "grub-efi-bootloader"
msgstr "grub-efi-bootloader"

msgid "Unsure whether to use EFI- or BIOS-based GRUB? If the directory @file{/sys/firmware/efi} exists in the installation image, then you should probably perform an EFI installation, using @code{grub-efi-bootloader}.  Otherwise you should use the BIOS-based GRUB, known as @code{grub-bootloader}.  @xref{Bootloader Configuration}, for more info on bootloaders."
msgstr "Não tem certeza se deve usar o GRUB baseado em EFI ou BIOS? Se o diretório @file{/sys/firmware/efi} existir na imagem de instalação, então você provavelmente deve executar uma instalação EFI, usando @code{grub-efi-bootloader}. Caso contrário, você deve usar o GRUB baseado em BIOS, conhecido como @code{grub-bootloader}. @xref{Bootloader Configuration}, para mais informações sobre bootloaders."

msgid "Once you are done partitioning the target hard disk drive, you have to create a file system on the relevant partition(s)@footnote{Currently Guix System only supports ext4, btrfs, JFS, F2FS, and XFS file systems.  In particular, code that reads file system UUIDs and labels only works for these file system types.}.  For the ESP, if you have one and assuming it is @file{/dev/sda1}, run:"
msgstr "Depois de terminar de particionar o disco rígido de destino, você precisa criar um sistema de arquivos na(s) partição(ões) relevante(s)@footnote{Atualmente, o Guix System suporta apenas sistemas de arquivos ext4, btrfs, JFS, F2FS e XFS. Em particular, o código que lê UUIDs e rótulos do sistema de arquivos funciona apenas para esses tipos de sistema de arquivos.}. Para o ESP, se você tiver um e presumindo que seja @file{/dev/sda1}, execute:"

msgid "mkfs.fat -F32 /dev/sda1\n"
msgstr "mkfs.fat -F32 /dev/sda1\n"

msgid "For the root file system, ext4 is the most widely used format.  Other file systems, such as Btrfs, support compression, which is reported to nicely complement file deduplication that the daemon performs independently of the file system (@pxref{Invoking guix-daemon, deduplication})."
msgstr "Para o sistema de arquivos raiz, ext4 é o formato mais amplamente usado. Outros sistemas de arquivos, como Btrfs, suportam compressão, que é relatada como um bom complemento para a desduplicação de arquivos que o daemon executa independentemente do sistema de arquivos (@pxref{Invoking guix-daemon, deduplication})."

msgid "Preferably, assign file systems a label so that you can easily and reliably refer to them in @code{file-system} declarations (@pxref{File Systems}).  This is typically done using the @code{-L} option of @command{mkfs.ext4} and related commands.  So, assuming the target root partition lives at @file{/dev/sda2}, a file system with the label @code{my-root} can be created with:"
msgstr "De preferência, atribua um rótulo aos sistemas de arquivos para que você possa se referir a eles de forma fácil e confiável nas declarações @code{file-system} (@pxref{File Systems}). Isso normalmente é feito usando a opção @code{-L} de @command{mkfs.ext4} e comandos relacionados. Então, assumindo que a partição raiz de destino esteja em @file{/dev/sda2}, um sistema de arquivos com o rótulo @code{my-root} pode ser criado com:"

msgid "mkfs.ext4 -L my-root /dev/sda2\n"
msgstr "mkfs.ext4 -L my-root /dev/sda2\n"

msgid "encrypted disk"
msgstr "disco criptografado"

msgid "If you are instead planning to encrypt the root partition, you can use the Cryptsetup/LUKS utilities to do that (see @inlinefmtifelse{html, @uref{https://linux.die.net/man/8/cryptsetup, @code{man cryptsetup}}, @code{man cryptsetup}} for more information)."
msgstr "Se você estiver planejando criptografar a partição raiz, você pode usar os utilitários Cryptsetup/LUKS para fazer isso (veja @inlinefmtifelse{html, @uref{https://linux.die.net/man/8/cryptsetup, @code{man cryptsetup}}, @code{man cryptsetup}} para mais informações)."

msgid "Assuming you want to store the root partition on @file{/dev/sda2}, the command sequence to format it as a LUKS partition would be along these lines:"
msgstr "Supondo que você queira armazenar a partição raiz em @file{/dev/sda2}, a sequência de comandos para formatá-la como uma partição LUKS seria algo como isto:"

msgid ""
"cryptsetup luksFormat /dev/sda2\n"
"cryptsetup open /dev/sda2 my-partition\n"
"mkfs.ext4 -L my-root /dev/mapper/my-partition\n"
msgstr ""
"cryptsetup luksFormat /dev/sda2\n"
"cryptsetup open /dev/sda2 my-partition\n"
"mkfs.ext4 -L my-root /dev/mapper/my-partition\n"

msgid "Once that is done, mount the target file system under @file{/mnt} with a command like (again, assuming @code{my-root} is the label of the root file system):"
msgstr "Feito isso, monte o sistema de arquivos de destino em @file{/mnt} com um comando como (novamente, assumindo que @code{my-root} é o rótulo do sistema de arquivos raiz):"

msgid "mount LABEL=my-root /mnt\n"
msgstr "mount LABEL=my-root /mnt\n"

msgid "Also mount any other file systems you would like to use on the target system relative to this path.  If you have opted for @file{/boot/efi} as an EFI mount point for example, mount it at @file{/mnt/boot/efi} now so it is found by @code{guix system init} afterwards."
msgstr "Monte também quaisquer outros sistemas de arquivos que você gostaria de usar no sistema de destino em relação a este caminho. Se você optou por @file{/boot/efi} como um ponto de montagem EFI, por exemplo, monte-o em @file{/mnt/boot/efi} agora para que ele seja encontrado por @code{guix system init} depois."

msgid "Finally, if you plan to use one or more swap partitions (@pxref{Swap Space}), make sure to initialize them with @command{mkswap}.  Assuming you have one swap partition on @file{/dev/sda3}, you would run:"
msgstr "Por fim, se você planeja usar uma ou mais partições swap (@pxref{Swap Space}), certifique-se de inicializá-las com @command{mkswap}. Supondo que você tenha uma partição swap em @file{/dev/sda3}, você executaria:"

msgid ""
"mkswap /dev/sda3\n"
"swapon /dev/sda3\n"
msgstr ""
"mkswap /dev/sda3\n"
"swapon /dev/sda3\n"

msgid "Alternatively, you may use a swap file.  For example, assuming that in the new system you want to use the file @file{/swapfile} as a swap file, you would run@footnote{This example will work for many types of file systems (e.g., ext4).  However, for copy-on-write file systems (e.g., btrfs), the required steps may be different.  For details, see the manual pages for @command{mkswap} and @command{swapon}.}:"
msgstr "Alternativamente, você pode usar um arquivo de swap. Por exemplo, supondo que no novo sistema você queira usar o arquivo @file{/swapfile} como um arquivo de swap, você executaria @footnote{Este exemplo funcionará para muitos tipos de sistemas de arquivos (por exemplo, ext4). No entanto, para sistemas de arquivos copy-on-write (por exemplo, btrfs), as etapas necessárias podem ser diferentes. Para detalhes, veja as páginas do manual para @command{mkswap} e @command{swapon}.}:"

msgid ""
"# This is 10 GiB of swap space.  Adjust \"count\" to change the size.\n"
"dd if=/dev/zero of=/mnt/swapfile bs=1MiB count=10240\n"
"# For security, make the file readable and writable only by root.\n"
"chmod 600 /mnt/swapfile\n"
"mkswap /mnt/swapfile\n"
"swapon /mnt/swapfile\n"
msgstr ""
"# Este é 10 GiB de espaço de swap. Ajuste \"count\" para alterar o tamanho.\n"
"dd if=/dev/zero of=/mnt/swapfile bs=1MiB count=10240\n"
"# Por segurança, torne o arquivo legível e gravável somente pelo root.\n"
"chmod 600 /mnt/swapfile\n"
"mkswap /mnt/swapfile\n"
"swapon /mnt/swapfile\n"

msgid "Note that if you have encrypted the root partition and created a swap file in its file system as described above, then the encryption also protects the swap file, just like any other file in that file system."
msgstr "Observe que se você criptografou a partição raiz e criou um arquivo de swap em seu sistema de arquivos, conforme descrito acima, a criptografia também protegerá o arquivo de swap, assim como qualquer outro arquivo naquele sistema de arquivos."

msgid "With the target partitions ready and the target root mounted on @file{/mnt}, we're ready to go.  First, run:"
msgstr "Com as partições de destino prontas e a raiz de destino montada em @file{/mnt}, estamos prontos para começar. Primeiro, execute:"

msgid "herd start cow-store /mnt\n"
msgstr "herd start cow-store /mnt\n"

msgid "This makes @file{/gnu/store} copy-on-write, such that packages added to it during the installation phase are written to the target disk on @file{/mnt} rather than kept in memory.  This is necessary because the first phase of the @command{guix system init} command (see below) entails downloads or builds to @file{/gnu/store} which, initially, is an in-memory file system."
msgstr "Isso torna @file{/gnu/store} copy-on-write, de modo que os pacotes adicionados a ele durante a fase de instalação são gravados no disco de destino em @file{/mnt} em vez de mantidos na memória. Isso é necessário porque a primeira fase do comando @command{guix system init} (veja abaixo) envolve downloads ou compilações para @file{/gnu/store} que, inicialmente, é um sistema de arquivos na memória."

msgid "Next, you have to edit a file and provide the declaration of the operating system to be installed.  To that end, the installation system comes with three text editors.  We recommend GNU nano (@pxref{Top,,, nano, GNU nano Manual}), which supports syntax highlighting and parentheses matching; other editors include mg (an Emacs clone), and nvi (a clone of the original BSD @command{vi} editor).  We strongly recommend storing that file on the target root file system, say, as @file{/mnt/etc/config.scm}.  Failing to do that, you will have lost your configuration file once you have rebooted into the newly-installed system."
msgstr "Em seguida, você precisa editar um arquivo e fornecer a declaração do sistema operacional a ser instalado. Para isso, o sistema de instalação vem com três editores de texto. Recomendamos o GNU nano (@pxref{Top,,, nano, GNU nano Manual}), que suporta realce de sintaxe e correspondência de parênteses; outros editores incluem mg (um clone do Emacs) e nvi (um clone do editor original BSD @command{vi}). Recomendamos fortemente armazenar esse arquivo no sistema de arquivos raiz de destino, digamos, como @file{/mnt/etc/config.scm}. Se isso não for feito, você perderá seu arquivo de configuração depois de reinicializar o sistema recém-instalado."

msgid "@xref{Using the Configuration System}, for an overview of the configuration file.  The example configurations discussed in that section are available under @file{/etc/configuration} in the installation image.  Thus, to get started with a system configuration providing a graphical display server (a ``desktop'' system), you can run something along these lines:"
msgstr "@xref{Using the Configuration System}, para uma visão geral do arquivo de configuração. As configurações de exemplo discutidas nessa seção estão disponíveis em @file{/etc/configuration} na imagem de instalação. Assim, para começar com uma configuração de sistema fornecendo um servidor de exibição gráfica (um sistema ``desktop''), você pode executar algo como estas linhas:"

msgid ""
"# mkdir /mnt/etc\n"
"# cp /etc/configuration/desktop.scm /mnt/etc/config.scm\n"
"# nano /mnt/etc/config.scm\n"
msgstr ""
"# mkdir /mnt/etc\n"
"# cp /etc/configuration/desktop.scm /mnt/etc/config.scm\n"
"# nano /mnt/etc/config.scm\n"

msgid "You should pay attention to what your configuration file contains, and in particular:"
msgstr "Você deve prestar atenção ao que seu arquivo de configuração contém e, em particular:"

msgid "Make sure the @code{bootloader-configuration} form refers to the targets you want to install GRUB on.  It should mention @code{grub-bootloader} if you are installing GRUB in the legacy way, or @code{grub-efi-bootloader} for newer UEFI systems.  For legacy systems, the @code{targets} field contain the names of the devices, like @code{(list \"/dev/sda\")}; for UEFI systems it names the paths to mounted EFI partitions, like @code{(list \"/boot/efi\")}; do make sure the paths are currently mounted and a @code{file-system} entry is specified in your configuration."
msgstr "Certifique-se de que o formulário @code{bootloader-configuration} se refere aos alvos nos quais você deseja instalar o GRUB. Ele deve mencionar @code{grub-bootloader} se você estiver instalando o GRUB da maneira legada, ou @code{grub-efi-bootloader} para sistemas UEFI mais novos. Para sistemas legados, o campo @code{targets} contém os nomes dos dispositivos, como @code{(list \"/dev/sda\")}; para sistemas UEFI, ele nomeia os caminhos para partições EFI montadas, como @code{(list \"/boot/efi\")}; certifique-se de que os caminhos estejam montados no momento e que uma entrada @code{file-system} esteja especificada em sua configuração."

msgid "Be sure that your file system labels match the value of their respective @code{device} fields in your @code{file-system} configuration, assuming your @code{file-system} configuration uses the @code{file-system-label} procedure in its @code{device} field."
msgstr "Certifique-se de que os rótulos do seu sistema de arquivos correspondam ao valor dos respectivos campos @code{device} na sua configuração @code{file-system}, supondo que sua configuração @code{file-system} use o procedimento @code{file-system-label} no seu campo @code{device}."

msgid "If there are encrypted or RAID partitions, make sure to add a @code{mapped-devices} field to describe them (@pxref{Mapped Devices})."
msgstr "Se houver partições criptografadas ou RAID, certifique-se de adicionar um campo @code{mapped-devices} para descrevê-las (@pxref{Mapped Devices})."

msgid "Once you are done preparing the configuration file, the new system must be initialized (remember that the target root file system is mounted under @file{/mnt}):"
msgstr "Depois de terminar de preparar o arquivo de configuração, o novo sistema deve ser inicializado (lembre-se de que o sistema de arquivos raiz de destino é montado em @file{/mnt}):"

msgid "guix system init /mnt/etc/config.scm /mnt\n"
msgstr "guix system init /mnt/etc/config.scm /mnt\n"

msgid "This copies all the necessary files and installs GRUB on @file{/dev/sdX}, unless you pass the @option{--no-bootloader} option.  For more information, @pxref{Invoking guix system}.  This command may trigger downloads or builds of missing packages, which can take some time."
msgstr "Isso copia todos os arquivos necessários e instala o GRUB em @file{/dev/sdX}, a menos que você passe a opção @option{--no-bootloader}. Para mais informações, @pxref{Invoking guix system}. Este comando pode disparar downloads ou compilações de pacotes ausentes, o que pode levar algum tempo."

msgid "Once that command has completed---and hopefully succeeded!---you can run @command{reboot} and boot into the new system.  The @code{root} password in the new system is initially empty; other users' passwords need to be initialized by running the @command{passwd} command as @code{root}, unless your configuration specifies otherwise (@pxref{user-account-password, user account passwords}).  @xref{After System Installation}, for what's next!"
msgstr "Após a conclusão desse comando -- e esperamos que com sucesso! -- você pode executar o comando @command{reboot} e inicializar no novo sistema. A senha @code{root} no novo sistema está inicialmente vazia; as senhas de outros usuários precisam ser inicializadas executando o comando @command{passwd} como @code{root}, a menos que sua configuração especifique o contrário (@pxref{user-account-password, senhas de contas de usuário}). @xref{After System Installation}, para o que vem a seguir!"

msgid "This builds a new system @dfn{generation} with the latest packages and services."
msgstr "Isso cria uma nova @dfn{geração} sistema com os pacotes e serviços mais recentes."

msgid "Now, @pxref{Getting Started with the System}, and join us on @code{#guix} on the Libera.Chat IRC network or on @email{guix-devel@@gnu.org} to share your experience!"
msgstr "Agora, @pxref{Getting Started with the System}, junte-se a nós no @code{#guix} na rede IRC Libera.Chat ou no @email{guix-devel@@gnu.org} para compartilhar sua experiência!"

msgid "Installing Guix in a Virtual Machine"
msgstr "Instalando Guix em uma Máquina Virtual"

msgid "virtual machine, Guix System installation"
msgstr "máquina virtual, instalação do Guix System"

msgid "virtual private server (VPS)"
msgstr "servidor virtual privado (VPS)"

msgid "VPS (virtual private server)"
msgstr "VPS (servidor virtual privado)"

msgid "If you'd like to install Guix System in a virtual machine (VM) or on a virtual private server (VPS) rather than on your beloved machine, this section is for you."
msgstr "Se você deseja instalar o Guix System em uma máquina virtual (VM) ou em um servidor virtual privado (VPS) em vez de na sua máquina favorita, esta seção é para você."

msgid "To boot a @uref{https://qemu.org/,QEMU} VM for installing Guix System in a disk image, follow these steps:"
msgstr "Para inicializar uma VM @uref{https://qemu.org/,QEMU} para instalar o Guix System em uma imagem de disco, siga estas etapas:"

msgid "First, retrieve and decompress the Guix system installation image as described previously (@pxref{USB Stick and DVD Installation})."
msgstr "Primeiro, recupere e descompacte a imagem de instalação do sistema Guix conforme descrito anteriormente (@pxref{USB Stick and DVD Installation})."

msgid "Create a disk image that will hold the installed system.  To make a qcow2-formatted disk image, use the @command{qemu-img} command:"
msgstr "Crie uma imagem de disco que irá conter o sistema instalado. Para criar uma imagem de disco formatada em qcow2, use o comando @command{qemu-img}:"

msgid "qemu-img create -f qcow2 guix-system.img 50G\n"
msgstr "qemu-img create -f qcow2 guix-system.img 50G\n"

msgid "The resulting file will be much smaller than 50 GB (typically less than 1 MB), but it will grow as the virtualized storage device is filled up."
msgstr "O arquivo resultante será muito menor que 50 GB (normalmente menos de 1 MB), mas aumentará à medida que o dispositivo de armazenamento virtualizado for preenchido."

msgid ""
"qemu-system-x86_64 -m 1024 -smp 1 -enable-kvm \\\n"
"  -nic user,model=virtio-net-pci -boot menu=on,order=d \\\n"
"  -drive file=guix-system.img \\\n"
"  -drive media=cdrom,readonly=on,file=guix-system-install-@value{VERSION}.@var{system}.iso\n"
msgstr ""
"qemu-system-x86_64 -m 1024 -smp 1 -enable-kvm \\\n"
"  -nic user,model=virtio-net-pci -boot menu=on,order=d \\\n"
"  -drive file=guix-system.img \\\n"
"  -drive media=cdrom,readonly=on,file=guix-system-install-@value{VERSION}.@var{sistema}.iso\n"

msgid "@code{-enable-kvm} is optional, but significantly improves performance, @pxref{Running Guix in a VM}."
msgstr "@code{-enable-kvm} é opcional, mas melhora significativamente o desempenho, @pxref{Running Guix in a VM}."

msgid "You're now root in the VM, proceed with the installation process.  @xref{Preparing for Installation}, and follow the instructions."
msgstr "Agora você está como root na VM, prossiga com o processo de instalação. @xref{Preparing for Installation} e siga as instruções."

msgid "Once installation is complete, you can boot the system that's on your @file{guix-system.img} image.  @xref{Running Guix in a VM}, for how to do that."
msgstr "Quando a instalação estiver concluída, você pode inicializar o sistema que está na sua imagem @file{guix-system.img}. @xref{Running Guix in a VM}, para saber como fazer isso."

msgid "installation image"
msgstr "imagem de instalação"

msgid "The installation image described above was built using the @command{guix system} command, specifically:"
msgstr "A imagem de instalação descrita acima foi criada usando o comando @command{guix system}, especificamente:"

msgid "guix system image -t iso9660 gnu/system/install.scm\n"
msgstr "guix system image -t iso9660 gnu/system/install.scm\n"

msgid "Have a look at @file{gnu/system/install.scm} in the source tree, and see also @ref{Invoking guix system} for more information about the installation image."
msgstr "Dê uma olhada em @file{gnu/system/install.scm} na árvore de origem e veja também @ref{Invoking guix system} para mais informações sobre a imagem de instalação."

msgid "Building the Installation Image for ARM Boards"
msgstr "Construindo a imagem de instalação para placas ARM"

msgid "Many ARM boards require a specific variant of the @uref{https://www.denx.de/wiki/U-Boot/, U-Boot} bootloader."
msgstr "Muitas placas ARM exigem uma variante específica do bootloader @uref{https://www.denx.de/wiki/U-Boot/, U-Boot}."

msgid "If you build a disk image and the bootloader is not available otherwise (on another boot drive etc), it's advisable to build an image that includes the bootloader, specifically:"
msgstr "Se você criar uma imagem de disco e o bootloader não estiver disponível de outra forma (em outra unidade de inicialização, etc.), é aconselhável criar uma imagem que inclua o bootloader, especificamente:"

msgid "guix system image --system=armhf-linux -e '((@@ (gnu system install) os-with-u-boot) (@@ (gnu system install) installation-os) \"A20-OLinuXino-Lime2\")'\n"
msgstr "guix system image --system=armhf-linux -e '((@@ (gnu system install) os-with-u-boot) (@@ (gnu system install) installation-os) \"A20-OLinuXino-Lime2\")'\n"

msgid "@code{A20-OLinuXino-Lime2} is the name of the board.  If you specify an invalid board, a list of possible boards will be printed."
msgstr "@code{A20-OLinuXino-Lime2} é o nome do quadro. Se você especificar um quadro inválido, uma lista de quadros possíveis será mostrada."

msgid "Presumably, you've reached this section because either you have installed Guix on top of another distribution (@pxref{Installation}), or you've installed the standalone Guix System (@pxref{System Installation}).  It's time for you to get started using Guix and this section aims to help you do that and give you a feel of what it's like."
msgstr "Presumivelmente, você chegou a esta seção porque instalou o Guix sobre outra distribuição (@pxref{Installation}) ou instalou o Guix System autônomo (@pxref{System Installation}). É hora de começar a usar o Guix e esta seção tem como objetivo ajudar você a fazer isso e dar uma ideia de como é."

msgid "Guix is about installing software, so probably the first thing you'll want to do is to actually look for software.  Let's say you're looking for a text editor, you can run:"
msgstr "Guix é sobre instalar software, então provavelmente a primeira coisa que você vai querer fazer é realmente procurar por software. Digamos que você esteja procurando por um editor de texto, você pode executar:"

msgid "guix search text editor\n"
msgstr "guix search text editor\n"

msgid "This command shows you a number of matching @dfn{packages}, each time showing the package's name, version, a description, and additional info.  Once you've found out the one you want to use, let's say Emacs (ah ha!), you can go ahead and install it (run this command as a regular user, @emph{no need for root privileges}!):"
msgstr "Este comando mostra a você um número de @dfn{pacotes} correspondentes, cada vez mostrando o nome do pacote, versão, uma descrição e informações adicionais. Depois de descobrir qual você quer usar, digamos Emacs (ah ha!), você pode prosseguir e instalá-lo (execute este comando como um usuário regular, @emph{não precisa de privilégios de root}!):"

msgid "guix install emacs\n"
msgstr "guix install emacs\n"

msgid "profile"
msgstr "perfil"

msgid "You've installed your first package, congrats! The package is now visible in your default @dfn{profile}, @file{$HOME/.guix-profile}---a profile is a directory containing installed packages.  In the process, you've probably noticed that Guix downloaded pre-built binaries; or, if you explicitly chose to @emph{not} use pre-built binaries, then probably Guix is still building software (@pxref{Substitutes}, for more info)."
msgstr "Você instalou seu primeiro pacote, parabéns! O pacote agora está visível no seu @dfn{perfil} padrão, @file{$HOME/.guix-profile}---um perfil é um diretório que contém pacotes instalados. No processo, você provavelmente notou que o Guix baixou binários pré-compilados; ou, se você escolheu explicitamente @emph{não} usar binários pré-compilados, então provavelmente o Guix ainda está compilando software (@pxref{Substitutes}, para mais informações)."

msgid "Unless you're using Guix System, the @command{guix install} command must have printed this hint:"
msgstr "A menos que você esteja usando o Guix System, o comando @command{guix install} deve ter mostrado esta dica:"

msgid ""
"hint: Consider setting the necessary environment variables by running:\n"
"\n"
msgstr ""
"dica: Considere definir as variáveis de ambiente necessárias executando:\n"
"\n"

msgid ""
"     GUIX_PROFILE=\"$HOME/.guix-profile\"\n"
"     . \"$GUIX_PROFILE/etc/profile\"\n"
"\n"
msgstr ""
"     GUIX_PROFILE=\"$HOME/.guix-profile\"\n"
"     . \"$GUIX_PROFILE/etc/profile\"\n"
"\n"

msgid "Alternately, see `guix package --search-paths -p \"$HOME/.guix-profile\"'.\n"
msgstr "Alternativamente, consulte `guix package --search-paths -p \"$HOME/.guix-profile\"'.\n"

msgid "Indeed, you must now tell your shell where @command{emacs} and other programs installed with Guix are to be found.  Pasting the two lines above will do just that: it will add @code{$HOME/.guix-profile/bin}---which is where the installed package is---to the @code{PATH} environment variable.  You can paste these two lines in your shell so they take effect right away, but more importantly you should add them to @file{~/.bash_profile} (or equivalent file if you do not use Bash) so that environment variables are set next time you spawn a shell.  You only need to do this once and other search paths environment variables will be taken care of similarly---e.g., if you eventually install @code{python} and Python libraries, @env{GUIX_PYTHONPATH} will be defined."
msgstr "De fato, agora você deve informar ao seu shell onde @command{emacs} e outros programas instalados com Guix podem ser encontrados. Colar as duas linhas acima fará exatamente isso: adicionará @code{$HOME/.guix-profile/bin}---que é onde o pacote instalado está---à variável de ambiente @code{PATH}. Você pode colar essas duas linhas no seu shell para que elas entrem em vigor imediatamente, mas o mais importante é adicioná-las a @file{~/.bash_profile} (ou arquivo equivalente se você não usar Bash) para que as variáveis de ambiente sejam definidas na próxima vez que você gerar um shell. Você só precisa fazer isso uma vez e outras variáveis de ambiente de caminhos de busca serão cuidadas de forma semelhante---por exemplo, se você eventualmente instalar @code{python} e bibliotecas Python, @env{GUIX_PYTHONPATH} será definido."

msgid "You can go on installing packages at your will.  To list installed packages, run:"
msgstr "Você pode continuar instalando pacotes à vontade. Para listar os pacotes instalados, execute:"

msgid "guix package --list-installed\n"
msgstr "guix package --list-installed\n"

msgid "To remove a package, you would unsurprisingly run @command{guix remove}.  A distinguishing feature is the ability to @dfn{roll back} any operation you made---installation, removal, upgrade---by simply typing:"
msgstr "Para remover um pacote, você executaria, sem surpresa, @command{guix remove}. Um recurso diferenciador é a capacidade de @dfn{reverter} qualquer operação que você fez---instalação, remoção, atualização---simplesmente digitando:"

msgid "guix package --roll-back\n"
msgstr "guix package --roll-back\n"

msgid "This is because each operation is in fact a @dfn{transaction} that creates a new @dfn{generation}.  These generations and the difference between them can be displayed by running:"
msgstr "Isso ocorre porque cada operação é, na verdade, uma @dfn{transação} que cria uma nova @dfn{geração}. Essas gerações e a diferença entre elas podem ser exibidas executando:"

msgid "guix package --list-generations\n"
msgstr "guix package --list-generations\n"

msgid "Now you know the basics of package management!"
msgstr "Agora você conhece os conceitos básicos de gerenciamento de pacotes!"

msgid "Going further"
msgstr "Indo além"

msgid "@xref{Package Management}, for more about package management.  You may like @dfn{declarative} package management with @command{guix package --manifest}, managing separate @dfn{profiles} with @option{--profile}, deleting old generations, collecting garbage, and other nifty features that will come in handy as you become more familiar with Guix.  If you are a developer, @pxref{Development} for additional tools.  And if you're curious, @pxref{Features}, to peek under the hood."
msgstr "@xref{Package Management}, para mais informações sobre gerenciamento de pacotes. Você pode gostar do gerenciamento de pacotes @dfn{declarativo} com @command{guix package --manifest}, gerenciar @dfn{perfis} separados com @option{--profile}, excluir gerações antigas, coletar lixo e outros recursos interessantes que serão úteis à medida que você se familiarizar com o Guix. Se você for um desenvolvedor, @pxref{Development} para ferramentas adicionais. E se estiver curioso, @pxref{Features}, para dar uma olhada nos bastidores."

msgid "You can also manage the configuration of your entire @dfn{home environment}---your user ``dot files'', services, and packages---using Guix Home.  @xref{Home Configuration}, to learn more about it!"
msgstr "Você também pode gerenciar a configuração de todo o seu ambiente @dfn{pessoal} --- seus \"arquivos dot'' de usuário, serviços e pacotes --- usando o Guix Home. @xref{Home Configuration}, para saber mais sobre isso!"

msgid "Once you've installed a set of packages, you will want to periodically @emph{upgrade} them to the latest and greatest version.  To do that, you will first pull the latest revision of Guix and its package collection:"
msgstr "Depois de instalar um conjunto de pacotes, você vai querer @emph{atualizá-los} periodicamente para a versão mais recente e melhor. Para fazer isso, você primeiro vai puxar a revisão mais recente do Guix e sua coleção de pacotes:"

msgid "The end result is a new @command{guix} command, under @file{~/.config/guix/current/bin}.  Unless you're on Guix System, the first time you run @command{guix pull}, be sure to follow the hint that the command prints and, similar to what we saw above, paste these two lines in your terminal and @file{.bash_profile}:"
msgstr "O resultado final é um novo comando @command{guix}, em @file{~/.config/guix/current/bin}. A menos que você esteja no Guix System, na primeira vez que você executar @command{guix pull}, certifique-se de seguir a dica que o comando imprime e, similar ao que vimos acima, cole estas duas linhas no seu terminal e @file{.bash_profile}:"

msgid ""
"GUIX_PROFILE=\"$HOME/.config/guix/current\"\n"
". \"$GUIX_PROFILE/etc/profile\"\n"
msgstr ""
"GUIX_PROFILE=\"$HOME/.config/guix/current\"\n"
". \"$GUIX_PROFILE/etc/profile\"\n"

msgid "You must also instruct your shell to point to this new @command{guix}:"
msgstr "Você também deve instruir seu shell a apontar para este novo @command{guix}:"

msgid "hash guix\n"
msgstr "hash guix\n"

msgid "At this point, you're running a brand new Guix.  You can thus go ahead and actually upgrade all the packages you previously installed:"
msgstr "Neste ponto, você está executando um Guix novinho em folha. Você pode então prosseguir e realmente atualizar todos os pacotes que você instalou anteriormente:"

msgid "guix upgrade\n"
msgstr "guix upgrade\n"

msgid "As you run this command, you will see that binaries are downloaded (or perhaps some packages are built), and eventually you end up with the upgraded packages.  Should one of these upgraded packages not be to your liking, remember you can always roll back!"
msgstr "Ao executar este comando, você verá que os binários são baixados (ou talvez alguns pacotes são construídos) e, eventualmente, você acaba com os pacotes atualizados. Se um desses pacotes atualizados não for do seu agrado, lembre-se de que você sempre pode reverter!"

msgid "You can display the exact revision of Guix you're currently using by running:"
msgstr "Você pode exibir a revisão exata do Guix que está usando atualmente executando:"

msgid "guix describe\n"
msgstr "guix describe\n"

msgid "The information it displays is @emph{all it takes to reproduce the exact same Guix}, be it at a different point in time or on a different machine."
msgstr "As informações exibidas são @emph{tudo o que é necessário para reproduzir exatamente o mesmo Guix}, seja em um momento diferente ou em uma máquina diferente."

msgid "@xref{Invoking guix pull}, for more information.  @xref{Channels}, on how to specify additional @dfn{channels} to pull packages from, how to replicate Guix, and more.  You may also find @command{time-machine} handy (@pxref{Invoking guix time-machine})."
msgstr "@xref{Invoking guix pull}, para mais informações. @xref{Channels}, sobre como especificar @dfn{canais} adicionais para extrair pacotes, como replicar Guix e muito mais. Você também pode achar @command{time-machine} útil (@pxref{Invoking guix time-machine})."

msgid "If you installed Guix System, one of the first things you'll want to do is to upgrade your system.  Once you've run @command{guix pull} to get the latest Guix, you can upgrade the system like this:"
msgstr "Se você instalou o Guix System, uma das primeiras coisas que você vai querer fazer é atualizar seu sistema. Depois de executar @command{guix pull} para obter o Guix mais recente, você pode atualizar o sistema assim:"

msgid "sudo guix system reconfigure /etc/config.scm\n"
msgstr "sudo guix system reconfigure /etc/config.scm\n"

msgid "Upon completion, the system runs the latest versions of its software packages.  Just like for packages, you can always @emph{roll back} to a previous generation @emph{of the whole system}.  @xref{Getting Started with the System}, to learn how to manage your system."
msgstr "Após a conclusão, o sistema executa as versões mais recentes de seus pacotes de software. Assim como para pacotes, você sempre pode @emph{reverter} para uma geração anterior @emph{de todo o sistema}. @xref{Getting Started with the System}, para aprender como gerenciar seu sistema."

msgid "Now you know enough to get started!"
msgstr "Agora você sabe o suficiente para começar!"

msgid "Resources"
msgstr "Recursos"

msgid "The rest of this manual provides a reference for all things Guix.  Here are some additional resources you may find useful:"
msgstr "O restante deste manual fornece uma referência para todas as coisas do Guix. Aqui estão alguns recursos adicionais que você pode achar úteis:"

msgid "@xref{Top,,, guix-cookbook, The GNU Guix Cookbook}, for a list of ``how-to'' style of recipes for a variety of applications."
msgstr "@xref{Top,,, guix-cookbook.pt_BR, O Livro de Receitas do GNU Guix}, para uma lista de receitas no estilo \"como fazer\" para uma variedade de aplicações."

msgid "The @uref{https://guix.gnu.org/guix-refcard.pdf, GNU Guix Reference Card} lists in two pages most of the commands and options you'll ever need."
msgstr "O @uref{https://guix.gnu.org/guix-refcard.pdf, GNU Guix Reference Card} lista em duas páginas a maioria dos comandos e opções que você precisará."

msgid "The web site contains @uref{https://guix.gnu.org/en/videos/, instructional videos} covering topics such as everyday use of Guix, how to get help, and how to become a contributor."
msgstr "O site contém @uref{https://guix.gnu.org/en/videos/, vídeos instrucionais} que abordam tópicos como o uso diário do Guix, como obter ajuda e como se tornar um colaborador."

msgid "@xref{Documentation}, to learn how to access documentation on your computer."
msgstr "@xref{Documentation}, para aprender como acessar a documentação no seu computador."

msgid "We hope you will enjoy Guix as much as the community enjoys building it!"
msgstr "Esperamos que você goste do Guix tanto quanto a comunidade gosta de criá-lo!"

msgid "The purpose of GNU Guix is to allow users to easily install, upgrade, and remove software packages, without having to know about their build procedures or dependencies.  Guix also goes beyond this obvious set of features."
msgstr "O propósito do GNU Guix é permitir que os usuários instalem, atualizem e removam facilmente pacotes de software, sem precisar saber sobre seus procedimentos de construção ou dependências. O Guix também vai além desse conjunto óbvio de recursos."

msgid "This chapter describes the main features of Guix, as well as the package management tools it provides.  Along with the command-line interface described below (@pxref{Invoking guix package, @code{guix package}}), you may also use the Emacs-Guix interface (@pxref{Top,,, emacs-guix, The Emacs-Guix Reference Manual}), after installing @code{emacs-guix} package (run @kbd{M-x guix-help} command to start with it):"
msgstr "Este capítulo descreve os principais recursos do Guix, bem como as ferramentas de gerenciamento de pacotes que ele fornece. Junto com a interface de linha de comando descrita abaixo (@pxref{Invoking guix package, @code{guix package}}), você também pode usar a interface Emacs-Guix (@pxref{Top,,, emacs-guix, The Emacs-Guix Reference Manual}), após instalar o pacote @code{emacs-guix} (execute o comando @kbd{M-x guix-help} para começar com ele):"

msgid "guix install emacs-guix\n"
msgstr "guix install emacs-guix\n"

msgid "Here we assume you've already made your first steps with Guix (@pxref{Getting Started}) and would like to get an overview about what's going on under the hood."
msgstr "Aqui presumimos que você já deu os primeiros passos com o Guix (@pxref{Getting Started}) e gostaria de ter uma visão geral do que está acontecendo nos bastidores."

msgid "When using Guix, each package ends up in the @dfn{package store}, in its own directory---something that resembles @file{/gnu/store/xxx-package-1.2}, where @code{xxx} is a base32 string."
msgstr "Ao usar o Guix, cada pacote acaba no @dfn{armazém de pacotes}, em seu próprio diretório — algo que lembra @file{/gnu/store/xxx-package-1.2}, onde @code{xxx} é uma string base32."

msgid "Instead of referring to these directories, users have their own @dfn{profile}, which points to the packages that they actually want to use.  These profiles are stored within each user's home directory, at @code{$HOME/.guix-profile}."
msgstr "Em vez de se referir a esses diretórios, os usuários têm seu próprio @dfn{perfil}, que aponta para os pacotes que eles realmente querem usar. Esses perfis são armazenados dentro do diretório pessoal de cada usuário, em @code{$HOME/.guix-profile}."

msgid "For example, @code{alice} installs GCC 4.7.2.  As a result, @file{/home/alice/.guix-profile/bin/gcc} points to @file{/gnu/store/@dots{}-gcc-4.7.2/bin/gcc}.  Now, on the same machine, @code{bob} had already installed GCC 4.8.0.  The profile of @code{bob} simply continues to point to @file{/gnu/store/@dots{}-gcc-4.8.0/bin/gcc}---i.e., both versions of GCC coexist on the same system without any interference."
msgstr "Por exemplo, @code{alice} instala o GCC 4.7.2. Como resultado, @file{/home/alice/.guix-profile/bin/gcc} aponta para @file{/gnu/store/@dots{}-gcc-4.7.2/bin/gcc}. Agora, na mesma máquina, @code{bob} já tinha instalado o GCC 4.8.0. O perfil de @code{bob} simplesmente continua a apontar para @file{/gnu/store/@dots{}-gcc-4.8.0/bin/gcc}---ou seja, ambas as versões do GCC coexistem no mesmo sistema sem nenhuma interferência."

msgid "The @command{guix package} command is the central tool to manage packages (@pxref{Invoking guix package}).  It operates on the per-user profiles, and can be used @emph{with normal user privileges}."
msgstr "O comando @command{guix package} é a ferramenta central para gerenciar pacotes (@pxref{Invoking guix package}). Ele opera nos perfis por usuário e pode ser usado @emph{com privilégios normais de usuário}."

msgid "transactions"
msgstr "transações"

msgid "The command provides the obvious install, remove, and upgrade operations.  Each invocation is actually a @emph{transaction}: either the specified operation succeeds, or nothing happens.  Thus, if the @command{guix package} process is terminated during the transaction, or if a power outage occurs during the transaction, then the user's profile remains in its previous state, and remains usable."
msgstr "O comando fornece as operações óbvias de instalação, remoção e atualização. Cada invocação é, na verdade, uma @emph{transação}: ou a operação especificada é bem-sucedida ou nada acontece. Portanto, se o processo @command{guix package} for encerrado durante a transação, ou se ocorrer uma queda de energia durante a transação, o perfil do usuário permanecerá em seu estado anterior e continuará utilizável."

msgid "In addition, any package transaction may be @emph{rolled back}.  So, if, for example, an upgrade installs a new version of a package that turns out to have a serious bug, users may roll back to the previous instance of their profile, which was known to work well.  Similarly, the global system configuration on Guix is subject to transactional upgrades and roll-back (@pxref{Getting Started with the System})."
msgstr "Além disso, qualquer transação de pacote pode ser @emph{revertida}. Então, se, por exemplo, uma atualização instalar uma nova versão de um pacote que acabe tendo um bug sério, os usuários podem reverter para a instância anterior de seu perfil, que era conhecida por funcionar bem. Da mesma forma, a configuração global do sistema no Guix está sujeita a atualizações transacionais e roll-back (@pxref{Getting Started with the System})."

msgid "All packages in the package store may be @emph{garbage-collected}.  Guix can determine which packages are still referenced by user profiles, and remove those that are provably no longer referenced (@pxref{Invoking guix gc}).  Users may also explicitly remove old generations of their profile so that the packages they refer to can be collected."
msgstr "Todos os pacotes no repositório de pacotes podem ser @emph{garbage-collected}. O Guix pode determinar quais pacotes ainda são referenciados por perfis de usuário e remover aqueles que comprovadamente não são mais referenciados (@pxref{Invoking guix gc}). Os usuários também podem remover explicitamente gerações antigas de seus perfis para que os pacotes aos quais eles se referem possam ser coletados."

msgid "reproducibility"
msgstr "reprodutibilidade"

msgid "Guix takes a @dfn{purely functional} approach to package management, as described in the introduction (@pxref{Introduction}).  Each @file{/gnu/store} package directory name contains a hash of all the inputs that were used to build that package---compiler, libraries, build scripts, etc.  This direct correspondence allows users to make sure a given package installation matches the current state of their distribution.  It also helps maximize @dfn{build reproducibility}: thanks to the isolated build environments that are used, a given build is likely to yield bit-identical files when performed on different machines (@pxref{Invoking guix-daemon, container})."
msgstr "Guix adota uma abordagem @dfn{puramente funcional} para gerenciamento de pacotes, conforme descrito na introdução (@pxref{Introduction}). Cada nome de diretório de pacote @file{/gnu/store} contém um hash de todas as entradas que foram usadas para construir aquele pacote---compilador, bibliotecas, scripts de construção, etc. Essa correspondência direta permite que os usuários tenham certeza de que uma determinada instalação de pacote corresponde ao estado atual de sua distribuição. Também ajuda a maximizar a @dfn{reprodutibilidade da construção}: graças aos ambientes de construção isolados que são usados, uma determinada construção provavelmente produzirá arquivos de bits idênticos quando executada em máquinas diferentes (@pxref{Invoking guix-daemon, container})."

msgid "This foundation allows Guix to support @dfn{transparent binary/source deployment}.  When a pre-built binary for a @file{/gnu/store} item is available from an external source---a @dfn{substitute}, Guix just downloads it and unpacks it; otherwise, it builds the package from source, locally (@pxref{Substitutes}).  Because build results are usually bit-for-bit reproducible, users do not have to trust servers that provide substitutes: they can force a local build and @emph{challenge} providers (@pxref{Invoking guix challenge})."
msgstr "Essa base permite que o Guix suporte @dfn{transparent binary/source deployment}. Quando um binário pré-construído para um item @file{/gnu/store} está disponível em uma fonte externa---um @dfn{substituto}, o Guix apenas o baixa e descompacta; caso contrário, ele constrói o pacote a partir da fonte, localmente (@pxref{Substitutes}). Como os resultados da construção são geralmente reproduzíveis bit a bit, os usuários não precisam confiar em servidores que fornecem substitutos: eles podem forçar uma construção local e @emph{desafiar} os provedores (@pxref{Invoking guix challenge})."

msgid "Control over the build environment is a feature that is also useful for developers.  The @command{guix shell} command allows developers of a package to quickly set up the right development environment for their package, without having to manually install the dependencies of the package into their profile (@pxref{Invoking guix shell})."
msgstr "O controle sobre o ambiente de construção é um recurso que também é útil para desenvolvedores. O comando @command{guix shell} permite que os desenvolvedores de um pacote configurem rapidamente o ambiente de desenvolvimento correto para seu pacote, sem ter que instalar manualmente as dependências do pacote em seu perfil (@pxref{Invoking guix shell})."

msgid "replication, of software environments"
msgstr "replicação, de ambientes de software"

msgid "provenance tracking, of software artifacts"
msgstr "rastreamento de proveniência, de artefatos de software"

msgid "All of Guix and its package definitions is version-controlled, and @command{guix pull} allows you to ``travel in time'' on the history of Guix itself (@pxref{Invoking guix pull}).  This makes it possible to replicate a Guix instance on a different machine or at a later point in time, which in turn allows you to @emph{replicate complete software environments}, while retaining precise @dfn{provenance tracking} of the software."
msgstr "Todo o Guix e suas definições de pacote são controlados por versão, e @command{guix pull} permite que você \"viaje no tempo'' no histórico do próprio Guix (@pxref{Invoking guix pull}). Isso torna possível replicar uma instância do Guix em uma máquina diferente ou em um ponto posterior no tempo, o que por sua vez permite que você @emph{replique ambientes de software completos}, enquanto retém o @dfn{rastreamento de procedência} preciso do software."

msgid "Invoking @command{guix package}"
msgstr "Invocando @command{guix package}"

msgid "installing packages"
msgstr "instalando pacotes"

msgid "removing packages"
msgstr "removendo pacotes"

msgid "package installation"
msgstr "instalação de pacote"

msgid "package removal"
msgstr "remoção de pacote"

msgid "guix package"
msgstr "guix package"

msgid "The @command{guix package} command is the tool that allows users to install, upgrade, and remove packages, as well as rolling back to previous configurations.  These operations work on a user @dfn{profile}---a directory of installed packages.  Each user has a default profile in @file{$HOME/.guix-profile}.  The command operates only on the user's own profile, and works with normal user privileges (@pxref{Features}).  Its syntax is:"
msgstr "O comando @command{guix package} é a ferramenta que permite aos usuários instalar, atualizar e remover pacotes, bem como reverter para configurações anteriores. Essas operações funcionam no @dfn{perfil} de um usuário---um diretório de pacotes instalados. Cada usuário tem um perfil padrão em @file{$HOME/.guix-profile}. O comando opera apenas no próprio perfil do usuário e funciona com privilégios de usuário normais (@pxref{Features}). Sua sintaxe é:"

msgid "guix package @var{options}\n"
msgstr "guix package @var{opções}\n"

msgid "Primarily, @var{options} specifies the operations to be performed during the transaction.  Upon completion, a new profile is created, but previous @dfn{generations} of the profile remain available, should the user want to roll back."
msgstr "Principalmente, @var{opções} especifica as operações a serem executadas durante a transação. Após a conclusão, um novo perfil é criado, mas as @dfn{gerações} anteriores do perfil permanecem disponíveis, caso o usuário queira reverter."

msgid "For example, to remove @code{lua} and install @code{guile} and @code{guile-cairo} in a single transaction:"
msgstr "Por exemplo, para remover @code{lua} e instalar @code{guile} e @code{guile-cairo} em uma única transação:"

msgid "guix package -r lua -i guile guile-cairo\n"
msgstr "guix package -r lua -i guile guile-cairo\n"

msgid "aliases, for @command{guix package}"
msgstr "aliases, para @command{guix package}"

msgid "For your convenience, we also provide the following aliases:"
msgstr "Para sua conveniência, também fornecemos os seguintes aliases:"

msgid "@command{guix search} is an alias for @command{guix package -s},"
msgstr "@command{guix search} é um alias para @command{guix package -s},"

msgid "@command{guix install} is an alias for @command{guix package -i},"
msgstr "@command{guix install} é um alias para @command{guix package -i},"

msgid "@command{guix remove} is an alias for @command{guix package -r},"
msgstr "@command{guix remove} é um alias para @command{guix package -r},"

msgid "@command{guix upgrade} is an alias for @command{guix package -u},"
msgstr "@command{guix upgrade} é um alias para @command{guix package -u},"

msgid "and @command{guix show} is an alias for @command{guix package --show=}."
msgstr "e @command{guix show} é um alias para @command{guix package --show=}."

msgid "These aliases are less expressive than @command{guix package} and provide fewer options, so in some cases you'll probably want to use @command{guix package} directly."
msgstr "Esses aliases são menos expressivos que @command{guix package} e oferecem menos opções, então em alguns casos você provavelmente desejará usar @command{guix package} diretamente."

msgid "@command{guix package} also supports a @dfn{declarative approach} whereby the user specifies the exact set of packages to be available and passes it @i{via} the @option{--manifest} option (@pxref{profile-manifest, @option{--manifest}})."
msgstr "@command{guix package} também suporta uma @dfn{abordagem declarativa} em que o usuário especifica o conjunto exato de pacotes que estarão disponíveis e passa a ele @i{via} a opção @option{--manifest} (@pxref{profile-manifest, @option{--manifest}})."

msgid "For each user, a symlink to the user's default profile is automatically created in @file{$HOME/.guix-profile}.  This symlink always points to the current generation of the user's default profile.  Thus, users can add @file{$HOME/.guix-profile/bin} to their @env{PATH} environment variable, and so on."
msgstr "Para cada usuário, uma ligação simbólica para o perfil padrão do usuário é criado automaticamente em @file{$HOME/.guix-profile}. Esta ligação simbólico sempre aponta para a geração atual do perfil padrão do usuário. Assim, os usuários podem adicionar @file{$HOME/.guix-profile/bin} à sua variável de ambiente @env{PATH} e assim por diante."

msgid "search paths"
msgstr "caminhos de pesquisa"

msgid "If you are not using Guix System, consider adding the following lines to your @file{~/.bash_profile} (@pxref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}) so that newly-spawned shells get all the right environment variable definitions:"
msgstr "Se você não estiver usando o sistema Guix, considere adicionar as seguintes linhas ao seu @file{~/.bash_profile} (@pxref{Bash Startup Files,,, bash, Manual de referência do GNU Bash}) para que os shells recém-gerados obtenham todos as definições corretas de variáveis de ambiente:"

msgid ""
"GUIX_PROFILE=\"$HOME/.guix-profile\" ; \\\n"
"source \"$GUIX_PROFILE/etc/profile\"\n"
msgstr ""
"GUIX_PROFILE=\"$HOME/.guix-profile\" ; \\\n"
"source \"$GUIX_PROFILE/etc/profile\"\n"

msgid "In a multi-user setup, user profiles are stored in a place registered as a @dfn{garbage-collector root}, which @file{$HOME/.guix-profile} points to (@pxref{Invoking guix gc}).  That directory is normally @code{@var{localstatedir}/guix/profiles/per-user/@var{user}}, where @var{localstatedir} is the value passed to @code{configure} as @option{--localstatedir}, and @var{user} is the user name.  The @file{per-user} directory is created when @command{guix-daemon} is started, and the @var{user} sub-directory is created by @command{guix package}."
msgstr "Em uma configuração multiusuário, os perfis de usuário são armazenados em um local registrado como @dfn{raiz do coletor de lixo}, para o qual @file{$HOME/.guix-profile} aponta (@pxref{Invoking guix gc}). Esse diretório geralmente é @code{@var{localstatedir}/guix/profiles/per-user/@var{usuário}}, onde @var{localstatedir} é o valor passado para @code{configure} como @option{-- localstatedir} e @var{usuário} é o nome do usuário. O diretório @file{per-user} é criado quando @command{guix-daemon} é iniciado, e o subdiretório @var{usuário} é criado por @command{guix package}."

msgid "The @var{options} can be among the following:"
msgstr "As seguintes @var{opções} podem ser usadas:"

msgid "--install=@var{package} @dots{}"
msgstr "--install=@var{pacote} @dots{}"

msgid "-i @var{package} @dots{}"
msgstr "-i @var{pacote} @dots{}"

msgid "Install the specified @var{package}s."
msgstr "Instale os @var{pacote}s especificados."

msgid "Each @var{package} may specify a simple package name, such as @code{guile}, optionally followed by an at-sign and version number, such as @code{guile@@3.0.7} or simply @code{guile@@3.0}.  In the latter case, the newest version prefixed by @code{3.0} is selected."
msgstr "Cada @var{pacote} pode especificar um nome de pacote simples como @code{guile}, opcionalmente seguido por uma arroba e número de versão, como @code{guile@@3.0.7} ou simplesmente @code{guile@@3.0}. Neste último caso, a versão mais recente prefixada por @code{3.0} é selecionada."

msgid "If no version number is specified, the newest available version will be selected.  In addition, such a @var{package} specification may contain a colon, followed by the name of one of the outputs of the package, as in @code{gcc:doc} or @code{binutils@@2.22:lib} (@pxref{Packages with Multiple Outputs})."
msgstr "Se nenhum número de versão for especificado, a versão mais recente disponível será selecionada. Além disso, tal especificação @var{pacote} pode conter dois pontos, seguido pelo nome de uma das saídas do pacote, como em @code{gcc:doc} ou @code{binutils@@2.22:lib} (@pxref{Packages with Multiple Outputs})."

msgid "Packages with a corresponding name (and optionally version) are searched for among the GNU distribution modules (@pxref{Package Modules})."
msgstr "Pacotes com um nome correspondente (e opcionalmente versão) são procurados entre os módulos de distribuição GNU (@pxref{Package Modules})."

msgid "Alternatively, a @var{package} can directly specify a store file name such as @file{/gnu/store/...-guile-3.0.7}, as produced by, e.g., @code{guix build}."
msgstr "Alternativamente, um @var{pacote} pode especificar diretamente um nome de arquivo de armazém como @file{/gnu/store/...-guile-3.0.7}, conforme produzido por, por exemplo, @code{guix build}."

msgid "propagated inputs"
msgstr "entradas propagadas"

msgid "Sometimes packages have @dfn{propagated inputs}: these are dependencies that automatically get installed along with the required package (@pxref{package-propagated-inputs, @code{propagated-inputs} in @code{package} objects}, for information about propagated inputs in package definitions)."
msgstr "Às vezes, os pacotes têm @dfn{propagated-inputs}: são dependências que são instaladas automaticamente junto com o pacote necessário (@pxref{package-propagated-inputs, @code{propagated-inputs} em @code{package} objetos}, para obter informações sobre entradas propagadas em definições de pacote)."

msgid "package-cmd-propagated-inputs"
msgstr "package-cmd-propagated-inputs"

msgid "An example is the GNU MPC library: its C header files refer to those of the GNU MPFR library, which in turn refer to those of the GMP library.  Thus, when installing MPC, the MPFR and GMP libraries also get installed in the profile; removing MPC also removes MPFR and GMP---unless they had also been explicitly installed by the user."
msgstr "Um exemplo é a biblioteca GNU MPC: seus arquivos de cabeçalho C referem-se aos da biblioteca GNU MPFR, que por sua vez se refere aos da biblioteca GMP. Assim, ao instalar o MPC, as bibliotecas MPFR e GMP também são instaladas no perfil; a remoção do MPC também remove o MPFR e o GMP --- a menos que eles também tenham sido explicitamente instalados pelo usuário."

msgid "Besides, packages sometimes rely on the definition of environment variables for their search paths (see explanation of @option{--search-paths} below).  Any missing or possibly incorrect environment variable definitions are reported here."
msgstr "Além disso, os pacotes às vezes dependem da definição de variáveis de ambiente para seus caminhos de pesquisa (veja a explicação de @option{--search-paths} abaixo). Quaisquer definições de variáveis ambientais ausentes ou possivelmente incorretas são relatadas aqui."

msgid "--install-from-expression=@var{exp}"
msgstr "--install-from-expression=@var{exp}"

msgid "-e @var{exp}"
msgstr "-e @var{exp}"

msgid "Install the package @var{exp} evaluates to."
msgstr "Instale o pacote avaliado por @var{exp}."

msgid "@var{exp} must be a Scheme expression that evaluates to a @code{<package>} object.  This option is notably useful to disambiguate between same-named variants of a package, with expressions such as @code{(@@ (gnu packages commencement) guile-final)}."
msgstr "@var{exp} deve ser uma expressão de Scheme avaliada como um objeto @code{<package>}. Esta opção é particularmente útil para desambiguar variantes de um pacote com o mesmo nome, com expressões como @code{(@@(gnu packages commencement) guile-final)}."

msgid "Note that this option installs the first output of the specified package, which may be insufficient when needing a specific output of a multiple-output package."
msgstr "Observe que esta opção instala a primeira saída do pacote especificado, o que pode ser insuficiente quando for necessária uma saída específica de um pacote de múltiplas saídas."

msgid "--install-from-file=@var{file}"
msgstr "--install-from-file=@var{arquivo}"

msgid "-f @var{file}"
msgstr "-f @var{arquivo}"

msgid "Install the package that the code within @var{file} evaluates to."
msgstr "Instale o pacote avaliado pelo código em @var{arquivo}."

msgid "As an example, @var{file} might contain a definition like this (@pxref{Defining Packages}):"
msgstr "Por exemplo, @var{arquivo} pode conter uma definição como esta (@pxref{Defining Packages}):"

msgid "package-hello.scm"
msgstr "package-hello.scm"

msgid "Developers may find it useful to include such a @file{guix.scm} file in the root of their project source tree that can be used to test development snapshots and create reproducible development environments (@pxref{Invoking guix shell})."
msgstr "Os desenvolvedores podem achar útil incluir um arquivo @file{guix.scm} na raiz da árvore de origem do projeto que pode ser usado para testar instantâneos de desenvolvimento e criar ambientes de desenvolvimento reproduzíveis (@pxref{Invoking guix shell})."

msgid "The @var{file} may also contain a JSON representation of one or more package definitions.  Running @code{guix package -f} on @file{hello.json} with the following contents would result in installing the package @code{greeter} after building @code{myhello}:"
msgstr "O @var{arquivo} também pode conter uma representação JSON de uma ou mais definições de pacote. Executar @code{guix package -f} em @file{hello.json} com o seguinte conteúdo resultaria na instalação do pacote @code{greeter} após construir @code{myhello}:"

msgid "@verbatiminclude package-hello.json\n"
msgstr "@verbatiminclude package-hello.json\n"

msgid "--remove=@var{package} @dots{}"
msgstr "--remove=@var{pacote} @dots{}"

msgid "-r @var{package} @dots{}"
msgstr "-r @var{pacote} @dots{}"

msgid "Remove the specified @var{package}s."
msgstr "Remova os @var{pacote}s especificados."

msgid "As for @option{--install}, each @var{package} may specify a version number and/or output name in addition to the package name.  For instance, @samp{-r glibc:debug} would remove the @code{debug} output of @code{glibc}."
msgstr "Quanto a @option{--install}, cada @var{pacote} pode especificar um número de versão e/ou nome de saída além do nome do pacote. Por exemplo, @samp{-r glibc:debug} removeria a saída de @code{glibc}."

msgid "--upgrade[=@var{regexp} @dots{}]"
msgstr "--upgrade[=@var{regexp} @dots{}]"

msgid "-u [@var{regexp} @dots{}]"
msgstr "-u [@var{regexp} @dots{}]"

msgid "upgrading packages"
msgstr "atualização de pacotes"

msgid "Upgrade all the installed packages.  If one or more @var{regexp}s are specified, upgrade only installed packages whose name matches a @var{regexp}.  Also see the @option{--do-not-upgrade} option below."
msgstr "Atualize todos os pacotes instalados. Se um ou mais @var{regexp}s forem especificados, atualize apenas os pacotes instalados cujo nome corresponda a um @var{regexp}. Veja também a opção @option{--do-not-upgrade} abaixo."

msgid "Note that this upgrades package to the latest version of packages found in the distribution currently installed.  To update your distribution, you should regularly run @command{guix pull} (@pxref{Invoking guix pull})."
msgstr "Note que isso atualiza o pacote para a versão mais recente dos pacotes encontrados na distribuição atualmente instalada. Para atualizar sua distribuição, você deve executar regularmente @command{guix pull} (@pxref{Invoking guix pull})."

msgid "package transformations, upgrades"
msgstr "transformações de pacotes, atualizações"

msgid "When upgrading, package transformations that were originally applied when creating the profile are automatically re-applied (@pxref{Package Transformation Options}).  For example, assume you first installed Emacs from the tip of its development branch with:"
msgstr "Ao atualizar, as transformações de pacote que foram aplicadas originalmente ao criar o perfil são automaticamente reaplicadas (@pxref{Package Transformation Options}). Por exemplo, suponha que você instalou o Emacs pela ponta do seu branch de desenvolvimento com:"

msgid "guix install emacs-next --with-branch=emacs-next=master\n"
msgstr "guix install emacs-next --with-branch=emacs-next=master\n"

msgid "Next time you run @command{guix upgrade}, Guix will again pull the tip of the Emacs development branch and build @code{emacs-next} from that checkout."
msgstr "Na próxima vez que você executar @command{guix upgrade}, o Guix puxará novamente a ponta do branch de desenvolvimento do Emacs e compilará @code{emacs-next} a partir desse checkout."

msgid "Note that transformation options such as @option{--with-branch} and @option{--with-source} depend on external state; it is up to you to ensure that they work as expected.  You can also discard a transformations that apply to a package by running:"
msgstr "Observe que opções de transformação como @option{--with-branch} e @option{--with-source} dependem do estado externo; cabe a você garantir que elas funcionem conforme o esperado. Você também pode descartar transformações que se aplicam a um pacote executando:"

msgid "guix install @var{package}\n"
msgstr "guix install @var{pacote}\n"

msgid "--do-not-upgrade[=@var{regexp} @dots{}]"
msgstr "--do-not-upgrade[=@var{regexp} @dots{}]"

msgid "When used together with the @option{--upgrade} option, do @emph{not} upgrade any packages whose name matches a @var{regexp}.  For example, to upgrade all packages in the current profile except those containing the substring ``emacs'':"
msgstr "Quando usado junto com a opção @option{--upgrade}, @emph{não} atualize nenhum pacote cujo nome corresponda a um @var{regexp}. Por exemplo, para atualizar todos os pacotes no perfil atual, exceto aqueles que contêm a substring \"emacs'':"

msgid "$ guix package --upgrade . --do-not-upgrade emacs\n"
msgstr "$ guix package --upgrade . --do-not-upgrade emacs\n"

msgid "profile-manifest"
msgstr "profile-manifest"

msgid "--manifest=@var{file}"
msgstr "--manifest=@var{arquivo}"

msgid "-m @var{file}"
msgstr "-m @var{arquivo}"

msgid "profile declaration"
msgstr "declaração de perfil"

msgid "profile manifest"
msgstr "manifesto de perfil"

msgid "Create a new generation of the profile from the manifest object returned by the Scheme code in @var{file}.  This option can be repeated several times, in which case the manifests are concatenated."
msgstr "Crie uma nova geração do perfil a partir do objeto manifest retornado pelo código Scheme em @var{arquivo}. Esta opção pode ser repetida várias vezes, em cujo caso os manifestos são concatenados."

msgid "This allows you to @emph{declare} the profile's contents rather than constructing it through a sequence of @option{--install} and similar commands.  The advantage is that @var{file} can be put under version control, copied to different machines to reproduce the same profile, and so on."
msgstr "Isso permite que você @emph{declarando} o conteúdo do perfil em vez de construí-lo por meio de uma sequência de @option{--install} e comandos similares. A vantagem é que @var{arquivo} pode ser colocado sob controle de versão, copiado para máquinas diferentes para reproduzir o mesmo perfil, e assim por diante."

msgid "@var{file} must return a @dfn{manifest} object, which is roughly a list of packages:"
msgstr "@var{arquivo} deve retornar um objeto @dfn{manifest}, que é aproximadamente uma lista de pacotes:"

msgid "packages->manifest"
msgstr "packages->manifest"

msgid ""
"(use-package-modules guile emacs)\n"
"\n"
msgstr ""
"(use-package-modules guile emacs)\n"
"\n"

msgid ""
"(packages->manifest\n"
" (list emacs\n"
"       guile-2.0\n"
"       ;; Use a specific package output.\n"
"       (list guile-2.0 \"debug\")))\n"
msgstr ""
"(packages->manifest\n"
" (list emacs\n"
"       guile-2.0\n"
"       ;; Usa uma saída de pacote específica.\n"
"       (list guile-2.0 \"debug\")))\n"

msgid "@xref{Writing Manifests}, for information on how to write a manifest.  @xref{export-manifest, @option{--export-manifest}}, to learn how to obtain a manifest file from an existing profile."
msgstr "@xref{Writing Manifests}, para obter informações sobre como escrever um manifesto. @xref{export-manifest, @option{--export-manifest}}, para aprender como obter um arquivo de manifesto de um perfil existente."

msgid "--roll-back"
msgstr "--roll-back"

msgid "rolling back"
msgstr "revertendo"

msgid "undoing transactions"
msgstr "desfazendo transações"

msgid "transactions, undoing"
msgstr "transações, desfazendo"

msgid "Roll back to the previous @dfn{generation} of the profile---i.e., undo the last transaction."
msgstr "Reverta para a @dfn{geração} anterior do perfil, ou seja, desfaça a última transação."

msgid "When combined with options such as @option{--install}, roll back occurs before any other actions."
msgstr "Quando combinado com opções como @option{--install}, a reversão ocorre antes de qualquer outra ação."

msgid "When rolling back from the first generation that actually contains installed packages, the profile is made to point to the @dfn{zeroth generation}, which contains no files apart from its own metadata."
msgstr "Ao reverter da primeira geração que realmente contém pacotes instalados, o perfil é feito para apontar para a @dfn{geração zero}, que não contém arquivos além de seus próprios metadados."

msgid "After having rolled back, installing, removing, or upgrading packages overwrites previous future generations.  Thus, the history of the generations in a profile is always linear."
msgstr "Após ter revertido, instalar, remover ou atualizar pacotes sobrescreve gerações futuras anteriores. Assim, o histórico das gerações em um perfil é sempre linear."

msgid "--switch-generation=@var{pattern}"
msgstr "--switch-generation=@var{padrão}"

msgid "-S @var{pattern}"
msgstr "-S @var{padrão}"

msgid "generations"
msgstr "gerações"

msgid "Switch to a particular generation defined by @var{pattern}."
msgstr "Mude para uma geração específica definida por @var{padrão}."

msgid "@var{pattern} may be either a generation number or a number prefixed with ``+'' or ``-''.  The latter means: move forward/backward by a specified number of generations.  For example, if you want to return to the latest generation after @option{--roll-back}, use @option{--switch-generation=+1}."
msgstr "@var{padrão} pode ser um número de geração ou um número prefixado com \"+'' ou \"-''. O último significa: mover para frente/para trás por um número especificado de gerações. Por exemplo, se você quiser retornar para a última geração após @option{--roll-back}, use @option{--switch-generation=+1}."

msgid "The difference between @option{--roll-back} and @option{--switch-generation=-1} is that @option{--switch-generation} will not make a zeroth generation, so if a specified generation does not exist, the current generation will not be changed."
msgstr "A diferença entre @option{--roll-back} e @option{--switch-generation=-1} é que @option{--switch-generation} não fará uma geração zero, então se uma geração especificada não existir, a geração atual não será alterada."

msgid "--search-paths[=@var{kind}]"
msgstr "--search-paths[=@var{tipo}]"

msgid "Report environment variable definitions, in Bash syntax, that may be needed in order to use the set of installed packages.  These environment variables are used to specify @dfn{search paths} for files used by some of the installed packages."
msgstr "Relata definições de variáveis de ambiente, na sintaxe Bash, que podem ser necessárias para usar o conjunto de pacotes instalados. Essas variáveis de ambiente são usadas para especificar @dfn{caminhos de busca} para arquivos usados por alguns dos pacotes instalados."

msgid "For example, GCC needs the @env{CPATH} and @env{LIBRARY_PATH} environment variables to be defined so it can look for headers and libraries in the user's profile (@pxref{Environment Variables,,, gcc, Using the GNU Compiler Collection (GCC)}).  If GCC and, say, the C library are installed in the profile, then @option{--search-paths} will suggest setting these variables to @file{@var{profile}/include} and @file{@var{profile}/lib}, respectively (@pxref{Search Paths}, for info on search path specifications associated with packages.)"
msgstr "Por exemplo, o GCC precisa que as variáveis de ambiente @env{CPATH} e @env{LIBRARY_PATH} sejam definidas para que ele possa procurar cabeçalhos e bibliotecas no perfil do usuário (@pxref{Environment Variables,,, gcc, Usando o GNU Compiler Collection (GCC)}). Se o GCC e, digamos, a biblioteca C estiverem instalados no perfil, então @option{--search-paths} sugerirá definir essas variáveis como @file{@var{perfil}/include} e @file{@var{perfil}/lib}, respectivamente (@pxref{Search Paths}, para obter informações sobre especificações de caminho de pesquisa associadas a pacotes.)"

msgid "The typical use case is to define these environment variables in the shell:"
msgstr "O caso de uso típico é definir essas variáveis de ambiente no shell:"

msgid "$ eval $(guix package --search-paths)\n"
msgstr "$ eval $(guix package --search-paths)\n"

msgid "@var{kind} may be one of @code{exact}, @code{prefix}, or @code{suffix}, meaning that the returned environment variable definitions will either be exact settings, or prefixes or suffixes of the current value of these variables.  When omitted, @var{kind} defaults to @code{exact}."
msgstr "@var{tipo} pode ser um dos seguintes: @code{exact}, @code{prefix} ou @code{suffix}, o que significa que as definições de variáveis de ambiente retornadas serão configurações exatas ou prefixos ou sufixos do valor atual dessas variáveis. Quando omitido, @var{tipo} assume como padrão @code{exact}."

msgid "This option can also be used to compute the @emph{combined} search paths of several profiles.  Consider this example:"
msgstr "Esta opção também pode ser usada para calcular os caminhos de busca @emph{combinados} de vários perfis. Considere este exemplo:"

msgid ""
"$ guix package -p foo -i guile\n"
"$ guix package -p bar -i guile-json\n"
"$ guix package -p foo -p bar --search-paths\n"
msgstr ""
"$ guix package -p foo -i guile\n"
"$ guix package -p bar -i guile-json\n"
"$ guix package -p foo -p bar --search-paths\n"

msgid "The last command above reports about the @env{GUILE_LOAD_PATH} variable, even though, taken individually, neither @file{foo} nor @file{bar} would lead to that recommendation."
msgstr "O último comando acima relata sobre a variável @env{GUILE_LOAD_PATH}, embora, considerados individualmente, nem @file{foo} nem @file{bar} levariam a essa recomendação."

msgid "--profile=@var{profile}"
msgstr "--profile=@var{perfil}"

msgid "-p @var{profile}"
msgstr "-p @var{perfil}"

msgid "Use @var{profile} instead of the user's default profile."
msgstr "Use @var{perfil} em vez do perfil padrão do usuário."

msgid "@var{profile} must be the name of a file that will be created upon completion.  Concretely, @var{profile} will be a mere symbolic link (``symlink'') pointing to the actual profile where packages are installed:"
msgstr "@var{perfil} deve ser o nome de um arquivo que será criado após a conclusão. Concretamente, @var{perfil} será uma mera ligação simbólica (\"symlink'') apontanda para o perfil real onde os pacotes estão instalados:"

msgid ""
"$ guix install hello -p ~/code/my-profile\n"
"@dots{}\n"
"$ ~/code/my-profile/bin/hello\n"
"Hello, world!\n"
msgstr ""
"$ guix install hello -p ~/code/my-profile\n"
"@dots{}\n"
"$ ~/code/my-profile/bin/hello\n"
"Olá, mundo!\n"

msgid "All it takes to get rid of the profile is to remove this symlink and its siblings that point to specific generations:"
msgstr "Tudo o que é preciso para se livrar do perfil é remover este link simbólico e seus irmãos que apontam para gerações específicas:"

msgid "$ rm ~/code/my-profile ~/code/my-profile-*-link\n"
msgstr "$ rm ~/code/my-profile ~/code/my-profile-*-link\n"

msgid "--list-profiles"
msgstr "--list-profiles"

msgid "List all the user's profiles:"
msgstr "Liste todos os perfis dos usuários:"

msgid ""
"$ guix package --list-profiles\n"
"/home/charlie/.guix-profile\n"
"/home/charlie/code/my-profile\n"
"/home/charlie/code/devel-profile\n"
"/home/charlie/tmp/test\n"
msgstr ""
"$ guix package --list-profiles\n"
"/home/charlie/.guix-profile\n"
"/home/charlie/code/my-profile\n"
"/home/charlie/code/devel-profile\n"
"/home/charlie/tmp/test\n"

msgid "When running as root, list all the profiles of all the users."
msgstr "Ao executar como root, liste todos os perfis de todos os usuários."

msgid "collisions, in a profile"
msgstr "colisões, em um perfil"

msgid "colliding packages in profiles"
msgstr "pacotes colidindo em perfis"

msgid "profile collisions"
msgstr "colisões de perfil"

msgid "--allow-collisions"
msgstr "--allow-collisions"

msgid "Allow colliding packages in the new profile.  Use at your own risk!"
msgstr "Permitir pacotes de colisão no novo perfil. Use por sua conta e risco!"

msgid "By default, @command{guix package} reports as an error @dfn{collisions} in the profile.  Collisions happen when two or more different versions or variants of a given package end up in the profile."
msgstr "Por padrão, @command{guix package} relata como um erro @dfn{collisions} no perfil. Colisões acontecem quando duas ou mais versões ou variantes diferentes de um determinado pacote acabam no perfil."

msgid "--bootstrap"
msgstr "--bootstrap"

msgid "Use the bootstrap Guile to build the profile.  This option is only useful to distribution developers."
msgstr "Use o bootstrap Guile para construir o perfil. Esta opção é útil somente para desenvolvedores de distribuição."

msgid "In addition to these actions, @command{guix package} supports the following options to query the current state of a profile, or the availability of packages:"
msgstr "Além dessas ações, @command{guix package} suporta as seguintes opções para consultar o estado atual de um perfil ou a disponibilidade de pacotes:"

msgid "--search=@var{regexp}"
msgstr "--search=@var{regexp}"

msgid "-s @var{regexp}"
msgstr "-s @var{regexp}"

msgid "guix-search"
msgstr "guix-search"

msgid "searching for packages"
msgstr "procurando por pacotes"

msgid "List the available packages whose name, synopsis, or description matches @var{regexp} (in a case-insensitive fashion), sorted by relevance.  Print all the metadata of matching packages in @code{recutils} format (@pxref{Top, GNU recutils databases,, recutils, GNU recutils manual})."
msgstr "Liste os pacotes disponíveis cujo nome, sinopse ou descrição correspondem a @var{regexp} (sem distinção entre maiúsculas e minúsculas), classificados por relevância. Imprima todos os metadados dos pacotes correspondentes no formato @code{recutils} (@pxref{Top, bancos de dados GNU recutils,, recutils, manual GNU recutils})."

msgid "This allows specific fields to be extracted using the @command{recsel} command, for instance:"
msgstr "Isso permite que campos específicos sejam extraídos usando o comando @command{recsel}, por exemplo:"

msgid ""
"$ guix package -s malloc | recsel -p name,version,relevance\n"
"name: jemalloc\n"
"version: 4.5.0\n"
"relevance: 6\n"
"\n"
msgstr ""
"$ guix package -s malloc | recsel -p name,version,relevance\n"
"name: jemalloc\n"
"version: 4.5.0\n"
"relevance: 6\n"
"\n"

msgid ""
"name: glibc\n"
"version: 2.25\n"
"relevance: 1\n"
"\n"
msgstr ""
"name: glibc\n"
"version: 2.25\n"
"relevance: 1\n"
"\n"

msgid ""
"name: libgc\n"
"version: 7.6.0\n"
"relevance: 1\n"
msgstr ""
"name: libgc\n"
"version: 7.6.0\n"
"relevance: 1\n"

msgid "Similarly, to show the name of all the packages available under the terms of the GNU@tie{}LGPL version 3:"
msgstr "Da mesma forma, para mostrar o nome de todos os pacotes disponíveis sob os termos da GNU@tie{}LGPL versão 3:"

msgid ""
"$ guix package -s \"\" | recsel -p name -e 'license ~ \"LGPL 3\"'\n"
"name: elfutils\n"
"\n"
msgstr ""
"$ guix package -s \"\" | recsel -p name -e 'license ~ \"LGPL 3\"'\n"
"name: elfutils\n"
"\n"

msgid ""
"name: gmp\n"
"@dots{}\n"
msgstr ""
"name: gmp\n"
"@dots{}\n"

msgid "It is also possible to refine search results using several @code{-s} flags to @command{guix package}, or several arguments to @command{guix search}.  For example, the following command returns a list of board games (this time using the @command{guix search} alias):"
msgstr "Também é possível refinar os resultados da pesquisa usando vários sinalizadores @code{-s} para @command{guix package}, ou vários argumentos para @command{guix search}. Por exemplo, o comando a seguir retorna uma lista de jogos de tabuleiro (desta vez usando o alias @command{guix search}):"

msgid ""
"$ guix search '\\<board\\>' game | recsel -p name\n"
"name: gnubg\n"
"@dots{}\n"
msgstr ""
"$ guix search '\\<board\\>' game | recsel -p name\n"
"name: gnubg\n"
"@dots{}\n"

msgid "If we were to omit @code{-s game}, we would also get software packages that deal with printed circuit boards; removing the angle brackets around @code{board} would further add packages that have to do with keyboards."
msgstr "Se omitissemos @code{-s game}, também teríamos pacotes de software que lidam com placas de circuito impresso; remover os colchetes angulares em torno de @code{board} adicionaria ainda mais pacotes relacionados a teclados."

msgid "And now for a more elaborate example.  The following command searches for cryptographic libraries, filters out Haskell, Perl, Python, and Ruby libraries, and prints the name and synopsis of the matching packages:"
msgstr "E agora um exemplo mais elaborado. O comando a seguir procura bibliotecas criptográficas, filtra as bibliotecas Haskell, Perl, Python e Ruby e imprime o nome e a sinopse dos pacotes correspondentes:"

msgid ""
"$ guix search crypto library | \\\n"
"    recsel -e '! (name ~ \"^(ghc|perl|python|ruby)\")' -p name,synopsis\n"
msgstr ""
"$ guix search crypto library | \\\n"
"    recsel -e '! (name ~ \"^(ghc|perl|python|ruby)\")' -p name,synopsis\n"

msgid "@xref{Selection Expressions,,, recutils, GNU recutils manual}, for more information on @dfn{selection expressions} for @code{recsel -e}."
msgstr "@xref{Selection Expressions,,, recutils, manual GNU recutils}, para obter mais informações sobre @dfn{expressões de seleção} para @code{recsel -e}."

msgid "--show=@var{package}"
msgstr "--show=@var{pacote}"

msgid "Show details about @var{package}, taken from the list of available packages, in @code{recutils} format (@pxref{Top, GNU recutils databases,, recutils, GNU recutils manual})."
msgstr "Exibe detalhes sobre @var{pacote}, retirados da lista de pacotes disponíveis, no formato @code{recutils} (@pxref{Top,GNU Recutils Databases,, recutils, GNU Recutils Manual})."

msgid ""
"$ guix package --show=guile | recsel -p name,version\n"
"name: guile\n"
"version: 3.0.5\n"
"\n"
msgstr ""
"$ guix package --show=guile | recsel -p name,version\n"
"name: guile\n"
"version: 3.0.5\n"
"\n"

msgid ""
"name: guile\n"
"version: 3.0.2\n"
"\n"
msgstr ""
"name: guile\n"
"version: 3.0.2\n"
"\n"

msgid ""
"name: guile\n"
"version: 2.2.7\n"
"@dots{}\n"
msgstr ""
"name: guile\n"
"version: 2.2.7\n"
"@dots{}\n"

msgid "You may also specify the full name of a package to only get details about a specific version of it (this time using the @command{guix show} alias):"
msgstr "Você também pode especificar o nome completo de um pacote para obter detalhes apenas sobre uma versão específica dele (desta vez usando o alias @command{guix show}):"

msgid ""
"$ guix show guile@@3.0.5 | recsel -p name,version\n"
"name: guile\n"
"version: 3.0.5\n"
msgstr ""
"$ guix show guile@@3.0.5 | recsel -p name,version\n"
"name: guile\n"
"version: 3.0.5\n"

msgid "--list-installed[=@var{regexp}]"
msgstr "--list-installed[=@var{regexp}]"

msgid "-I [@var{regexp}]"
msgstr "-I [@var{regexp}]"

msgid "List the currently installed packages in the specified profile, with the most recently installed packages shown last.  When @var{regexp} is specified, list only installed packages whose name matches @var{regexp}."
msgstr "Lista os pacotes instalados mais recentemente no perfil especificado, com os pacotes instalados mais recentemente mostrados por último. Quando @var{regexp} for especificado, liste apenas os pacotes instalados cujo nome corresponda a @var{regexp}."

msgid "For each installed package, print the following items, separated by tabs: the package name, its version string, the part of the package that is installed (for instance, @code{out} for the default output, @code{include} for its headers, etc.), and the path of this package in the store."
msgstr "Para cada pacote instalado, imprima os seguintes itens, separados por tabulações: o nome do pacote, sua string de versão e a parte do pacote que está instalada (por exemplo, @code{out} para a saída predefinida, @code{include} para os seus cabeçalhos, etc.) e o caminho deste pacote no armazém."

msgid "--list-available[=@var{regexp}]"
msgstr "--list-available[=@var{regexp}]"

msgid "-A [@var{regexp}]"
msgstr "-A [@var{regexp}]"

msgid "List packages currently available in the distribution for this system (@pxref{GNU Distribution}).  When @var{regexp} is specified, list only available packages whose name matches @var{regexp}."
msgstr "Lista de pacotes atualmente disponíveis na distribuição para este sistema (@pxref{GNU Distribution}). Quando @var{regexp} for especificado, liste apenas os pacotes disponíveis cujo nome corresponda a @var{regexp}."

msgid "For each package, print the following items separated by tabs: its name, its version string, the parts of the package (@pxref{Packages with Multiple Outputs}), and the source location of its definition."
msgstr "Para cada pacote, imprima os seguintes itens separados por tabulações: seu nome, sua string de versão, as partes do pacote (@pxref{Packages with Multiple Outputs}) e o local de origem de sua definição."

msgid "--list-generations[=@var{pattern}]"
msgstr "--list-generations[=@var{padrão}]"

msgid "-l [@var{pattern}]"
msgstr "-l [@var{padrão}]"

msgid "Return a list of generations along with their creation dates; for each generation, show the installed packages, with the most recently installed packages shown last.  Note that the zeroth generation is never shown."
msgstr "Retorne uma lista de gerações junto com suas datas de criação; para cada geração, exiba os pacotes instalados, com os pacotes instalados mais recentemente mostrados por último. Observe que a geração zero nunca é mostrada."

msgid "For each installed package, print the following items, separated by tabs: the name of a package, its version string, the part of the package that is installed (@pxref{Packages with Multiple Outputs}), and the location of this package in the store."
msgstr "Para cada pacote instalado, mostre os seguintes itens, separados por tabulações: o nome de um pacote, sua string de versão, a parte do pacote que está instalada (@pxref{Packages with Multiple Outputs}) e a localização deste pacote em o armazém."

msgid "When @var{pattern} is used, the command returns only matching generations.  Valid patterns include:"
msgstr "Quando @var{padrão} é usado, o comando retorna apenas gerações correspondentes. Os padrões válidos incluem:"

msgid "@emph{Integers and comma-separated integers}.  Both patterns denote"
msgstr "@emph{Inteiros e números inteiros separados por vírgula}. Ambos os padrões denotam"

msgid "generation numbers.  For instance, @option{--list-generations=1} returns the first one."
msgstr "números de geração. Por exemplo, @option{--list-generations=1} retorna o primeiro."

msgid "And @option{--list-generations=1,8,2} outputs three generations in the specified order.  Neither spaces nor trailing commas are allowed."
msgstr "E @option{--list-generations=1,8,2} gera três gerações na ordem especificada. Não são permitidos espaços nem vírgulas finais."

msgid "@emph{Ranges}.  @option{--list-generations=2..9} prints the"
msgstr "@emph{Intervalos}. @option{--list-generations=2..9} mostra o"

msgid "specified generations and everything in between.  Note that the start of a range must be smaller than its end."
msgstr "gerações especificadas e tudo mais. Observe que o início de um intervalo deve ser menor que o seu final."

msgid "It is also possible to omit the endpoint.  For example, @option{--list-generations=2..}, returns all generations starting from the second one."
msgstr "Também é possível omitir o ponto final. Por exemplo, @option{--list-generations=2..} retorna todas as gerações começando pela segunda."

msgid "@emph{Durations}.  You can also get the last @emph{N}@tie{}days, weeks,"
msgstr "@emph{Duração}. Você também pode visitar os últimos @emph{N}@tie{}dias, semanas,"

msgid "or months by passing an integer along with the first letter of the duration.  For example, @option{--list-generations=20d} lists generations that are up to 20 days old."
msgstr "ou meses passando um número inteiro junto com a primeira letra da duração. Por exemplo, @option{--list-generations=20d} lista gerações com até 20 dias."

msgid "--delete-generations[=@var{pattern}]"
msgstr "--delete-generations[=@var{padrão}]"

msgid "-d [@var{pattern}]"
msgstr "-d [@var{padrão}]"

msgid "When @var{pattern} is omitted, delete all generations except the current one."
msgstr "Quando @var{padrão} for omitido, exclua todas as gerações, exceto a atual."

msgid "This command accepts the same patterns as @option{--list-generations}.  When @var{pattern} is specified, delete the matching generations.  When @var{pattern} specifies a duration, generations @emph{older} than the specified duration match.  For instance, @option{--delete-generations=1m} deletes generations that are more than one month old."
msgstr "Este comando aceita os mesmos padrões de @option{--list-Generations}. Quando @var{pattern} for especificado, exclua as gerações correspondentes. Quando @var{padrão} especifica uma duração, as gerações @emph{mais antigas} que a duração especificada correspondem. Por exemplo, @option{--delete-generations=1m} exclui gerações com mais de um mês."

msgid "If the current generation matches, it is @emph{not} deleted.  Also, the zeroth generation is never deleted."
msgstr "Se a geração atual corresponder, ela será @emph{não} excluída. Além disso, a geração zero nunca é excluída."

msgid "Note that deleting generations prevents rolling back to them.  Consequently, this command must be used with care."
msgstr "Observe que a exclusão de gerações impede a reversão para elas. Conseqüentemente, este comando deve ser usado com cuidado."

msgid "manifest, exporting"
msgstr "manifesto, exportando"

msgid "export-manifest"
msgstr "export-manifest"

msgid "--export-manifest"
msgstr "--export-manifest"

msgid "Write to standard output a manifest suitable for @option{--manifest} corresponding to the chosen profile(s)."
msgstr "Escreva na saída padrão um manifesto adequado para @option{--manifest} correspondente ao(s) perfil(s) selecionado(s)."

msgid "This option is meant to help you migrate from the ``imperative'' operating mode---running @command{guix install}, @command{guix upgrade}, etc.---to the declarative mode that @option{--manifest} offers."
msgstr "Esta opção destina-se a ajudá-lo a migrar do modo operacional \"imperativo'' --- executando @command{guix install}, @command{guix upgrade}, etc.---para o modo declarativo que @option{--manifest} ofertas."

msgid "Be aware that the resulting manifest @emph{approximates} what your profile actually contains; for instance, depending on how your profile was created, it can refer to packages or package versions that are not exactly what you specified."
msgstr "Observe que o manifesto resultante @emph{aproxima} o que seu perfil realmente contém; por exemplo, dependendo de como seu perfil foi criado, ele pode se referir a pacotes ou versões de pacotes que não são exatamente o que você especificou."

msgid "Keep in mind that a manifest is purely symbolic: it only contains package names and possibly versions, and their meaning varies over time.  If you wish to ``pin'' channels to the revisions that were used to build the profile(s), see @option{--export-channels} below."
msgstr "Tenha em mente que um manifesto é puramente simbólico: ele contém apenas nomes de pacotes e possivelmente versões, e seu significado varia com o tempo. Se você quiser ``fixar'' canais nas revisões que foram usadas para construir o(s) perfil(es), veja @option{--export-channels} abaixo."

msgid "pinning, channel revisions of a profile"
msgstr "fixação, revisões de canal de um perfil"

msgid "--export-channels"
msgstr "--export-channels"

msgid "Write to standard output the list of channels used by the chosen profile(s), in a format suitable for @command{guix pull --channels} or @command{guix time-machine --channels} (@pxref{Channels})."
msgstr "Escreva na saída padrão a lista de canais usados pelo(s) perfil(s) selecionado(s), em um formato adequado para @command{guix pull --channels} ou @command{guix time-machine --channels} (@pxref{Channels}) . ."

msgid "Together with @option{--export-manifest}, this option provides information allowing you to replicate the current profile (@pxref{Replicating Guix})."
msgstr "Juntamente com @option{--export-manifest}, esta opção fornece informações que permitem replicar o perfil atual (@pxref{Replicating Guix})."

msgid "However, note that the output of this command @emph{approximates} what was actually used to build this profile.  In particular, a single profile might have been built from several different revisions of the same channel.  In that case, @option{--export-manifest} chooses the last one and writes the list of other revisions in a comment.  If you really need to pick packages from different channel revisions, you can use inferiors in your manifest to do so (@pxref{Inferiors})."
msgstr "No entanto, observe que a saída deste comando @emph{aproxima} o que foi realmente usado para construir este perfil. Em particular, um único perfil pode ter sido construído a partir de diversas revisões diferentes do mesmo canal. Nesse caso, @option{--export-manifest} escolhe a última e escreve a lista de outras revisões em um comentário. Se você realmente precisa escolher pacotes de análises de canais diferentes, você pode usar inferiores em seu manifesto para fazer isso (@pxref{Inferiors})."

msgid "Together with @option{--export-manifest}, this is a good starting point if you are willing to migrate from the ``imperative'' model to the fully declarative model consisting of a manifest file along with a channels file pinning the exact channel revision(s) you want."
msgstr "Juntamente com @option{--export-manifest}, este é um bom ponto de partida se você estiver disposto a migrar do modelo \"imperativo\" para o modelo totalmente declarativo que consiste em um arquivo de manifesto junto com um arquivo de canais fixando o canal exato revisão(ões) que você deseja."

msgid "Finally, since @command{guix package} may actually start build processes, it supports all the common build options (@pxref{Common Build Options}).  It also supports package transformation options, such as @option{--with-source}, and preserves them across upgrades (@pxref{Package Transformation Options})."
msgstr "Finalmente, como @command{guix package} pode realmente iniciar processos de construção, ele suporta todas as opções de construção comuns (@pxref{Common Build Options}). Ele também oferece suporte a opções de transformação de pacotes, como @option{--with-source}, e as preserva em atualizações (@pxref{Package Transformation Options})."

msgid "pre-built binaries"
msgstr "binários pré-construídos"

msgid "Guix supports transparent source/binary deployment, which means that it can either build things locally, or download pre-built items from a server, or both.  We call these pre-built items @dfn{substitutes}---they are substitutes for local build results.  In many cases, downloading a substitute is much faster than building things locally."
msgstr "Guix suporta implantação transparente de origem/binário, o que significa que ele pode construir coisas localmente ou baixar itens pré-construídos de um servidor, ou ambos. Chamamos esses itens pré-construídos de @dfn{substitutos}---eles são substitutos para resultados de construção local. Em muitos casos, baixar um substituto é muito mais rápido do que construir coisas localmente."

msgid "Substitutes can be anything resulting from a derivation build (@pxref{Derivations}).  Of course, in the common case, they are pre-built package binaries, but source tarballs, for instance, which also result from derivation builds, can be available as substitutes."
msgstr "Substitutos podem ser qualquer coisa resultante de uma construção de derivação (@pxref{Derivations}). Claro, no caso comum, eles são binários de pacotes pré-construídos, mas tarballs de origem, por exemplo, que também resultam de construções de derivação, podem estar disponíveis como substitutos."

msgid "build farm"
msgstr "fazenda de compilação"

msgid "@code{@value{SUBSTITUTE-SERVER-1}} and @code{@value{SUBSTITUTE-SERVER-2}} are both front-ends to official build farms that build packages from Guix continuously for some architectures, and make them available as substitutes.  These are the default source of substitutes; which can be overridden by passing the @option{--substitute-urls} option either to @command{guix-daemon} (@pxref{daemon-substitute-urls,, @code{guix-daemon --substitute-urls}})  or to client tools such as @command{guix package} (@pxref{client-substitute-urls,, client @option{--substitute-urls} option})."
msgstr "@code{@value{SUBSTITUTE-SERVER-1}} e @code{@value{SUBSTITUTE-SERVER-2}} são ambos front-ends para farms de build oficiais que constroem pacotes do Guix continuamente para algumas arquiteturas e os disponibilizam como substitutos. Essas são a fonte padrão de substitutos; que podem ser substituídos passando a opção @option{--substitute-urls} para @command{guix-daemon} (@pxref{daemon-substitute-urls,, @code{guix-daemon --substitute-urls}}) ou para ferramentas de cliente como @command{guix package} (@pxref{client-substitute-urls,, client @option{--substitute-urls} option})."

msgid "Substitute URLs can be either HTTP or HTTPS.  HTTPS is recommended because communications are encrypted; conversely, using HTTP makes all communications visible to an eavesdropper, who could use the information gathered to determine, for instance, whether your system has unpatched security vulnerabilities."
msgstr "URLs substitutos podem ser HTTP ou HTTPS. HTTPS é recomendado porque as comunicações são criptografadas; por outro lado, usar HTTP torna todas as comunicações visíveis para um bisbilhoteiro, que pode usar as informações coletadas para determinar, por exemplo, se seu sistema tem vulnerabilidades de segurança não corrigidas."

msgid "Substitutes from the official build farms are enabled by default when using Guix System (@pxref{GNU Distribution}).  However, they are disabled by default when using Guix on a foreign distribution, unless you have explicitly enabled them via one of the recommended installation steps (@pxref{Installation}).  The following paragraphs describe how to enable or disable substitutes for the official build farm; the same procedure can also be used to enable substitutes for any other substitute server."
msgstr "Substitutos das build farms oficiais são habilitados por padrão ao usar o Guix System (@pxref{GNU Distribution}). No entanto, eles são desabilitados por padrão ao usar o Guix em uma distribuição estrangeira, a menos que você os tenha habilitado explicitamente por meio de uma das etapas de instalação recomendadas (@pxref{Installation}). Os parágrafos a seguir descrevem como habilitar ou desabilitar substitutos para a build farm oficial; o mesmo procedimento também pode ser usado para habilitar substitutos para qualquer outro servidor substituto."

msgid "security"
msgstr "segurança"

msgid "access control list (ACL), for substitutes"
msgstr "lista de controle de acesso (ACL), para substitutos"

msgid "ACL (access control list), for substitutes"
msgstr "ACL (lista de controle de acesso), para substitutos"

msgid "To allow Guix to download substitutes from @code{@value{SUBSTITUTE-SERVER-1}}, @code{@value{SUBSTITUTE-SERVER-2}} or a mirror, you must add the relevant public key to the access control list (ACL) of archive imports, using the @command{guix archive} command (@pxref{Invoking guix archive}).  Doing so implies that you trust the substitute server to not be compromised and to serve genuine substitutes."
msgstr "Para permitir que o Guix baixe substitutos de @code{@value{SUBSTITUTE-SERVER-1}}, @code{@value{SUBSTITUTE-SERVER-2}} ou um espelho, você deve adicionar a chave pública relevante à lista de controle de acesso (ACL) de importações de arquivo, usando o comando @command{guix archive} (@pxref{Invoking guix archive}). Fazer isso implica que você confia que o servidor substituto não será comprometido e servirá substitutos genuínos."

msgid "If you are using Guix System, you can skip this section: Guix System authorizes substitutes from @code{@value{SUBSTITUTE-SERVER-1}} and @code{@value{SUBSTITUTE-SERVER-2}} by default."
msgstr "Se você estiver usando o Guix System, pode pular esta seção: O Guix System autoriza substitutos de @code{@value{SUBSTITUTE-SERVER-1}} e @code{@value{SUBSTITUTE-SERVER-2}} por padrão."

msgid "The public keys for each of the project maintained substitute servers are installed along with Guix, in @code{@var{prefix}/share/guix/}, where @var{prefix} is the installation prefix of Guix.  If you installed Guix from source, make sure you checked the GPG signature of @file{guix-@value{VERSION}.tar.gz}, which contains this public key file.  Then, you can run something like this:"
msgstr "As chaves públicas para cada um dos servidores substitutos mantidos pelo projeto são instaladas junto com o Guix, em @code{@var{prefix}/share/guix/}, onde @var{prefix} é o prefixo de instalação do Guix. Se você instalou o Guix a partir da fonte, certifique-se de verificar a assinatura GPG de @file{guix-@value{VERSION}.tar.gz}, que contém este arquivo de chave pública. Então, você pode executar algo como isto:"

msgid "Once this is in place, the output of a command like @code{guix build} should change from something like:"
msgstr "Uma vez que isso esteja pronto, a saída de um comando como @code{guix build} deve mudar de algo como:"

msgid ""
"$ guix build emacs --dry-run\n"
"The following derivations would be built:\n"
"   /gnu/store/yr7bnx8xwcayd6j95r2clmkdl1qh688w-emacs-24.3.drv\n"
"   /gnu/store/x8qsh1hlhgjx6cwsjyvybnfv2i37z23w-dbus-1.6.4.tar.gz.drv\n"
"   /gnu/store/1ixwp12fl950d15h2cj11c73733jay0z-alsa-lib-1.0.27.1.tar.bz2.drv\n"
"   /gnu/store/nlma1pw0p603fpfiqy7kn4zm105r5dmw-util-linux-2.21.drv\n"
"@dots{}\n"
msgstr ""
"$ guix build emacs --dry-run\n"
"A seguinte derivações seriam compiladas:\n"
"   /gnu/store/yr7bnx8xwcayd6j95r2clmkdl1qh688w-emacs-24.3.drv\n"
"   /gnu/store/x8qsh1hlhgjx6cwsjyvybnfv2i37z23w-dbus-1.6.4.tar.gz.drv\n"
"   /gnu/store/1ixwp12fl950d15h2cj11c73733jay0z-alsa-lib-1.0.27.1.tar.bz2.drv\n"
"   /gnu/store/nlma1pw0p603fpfiqy7kn4zm105r5dmw-util-linux-2.21.drv\n"
"@dots{}\n"

msgid "to something like:"
msgstr "para algo como:"

msgid ""
"$ guix build emacs --dry-run\n"
"112.3 MB would be downloaded:\n"
"   /gnu/store/pk3n22lbq6ydamyymqkkz7i69wiwjiwi-emacs-24.3\n"
"   /gnu/store/2ygn4ncnhrpr61rssa6z0d9x22si0va3-libjpeg-8d\n"
"   /gnu/store/71yz6lgx4dazma9dwn2mcjxaah9w77jq-cairo-1.12.16\n"
"   /gnu/store/7zdhgp0n1518lvfn8mb96sxqfmvqrl7v-libxrender-0.9.7\n"
"@dots{}\n"
msgstr ""
"$ guix build emacs --dry-run\n"
"112.3 MB seriam baixados:\n"
"   /gnu/store/pk3n22lbq6ydamyymqkkz7i69wiwjiwi-emacs-24.3\n"
"   /gnu/store/2ygn4ncnhrpr61rssa6z0d9x22si0va3-libjpeg-8d\n"
"   /gnu/store/71yz6lgx4dazma9dwn2mcjxaah9w77jq-cairo-1.12.16\n"
"   /gnu/store/7zdhgp0n1518lvfn8mb96sxqfmvqrl7v-libxrender-0.9.7\n"
"@dots{}\n"

msgid "The text changed from ``The following derivations would be built'' to ``112.3 MB would be downloaded''.  This indicates that substitutes from the configured substitute servers are usable and will be downloaded, when possible, for future builds."
msgstr "O texto mudou de \"As seguintes derivações seriam construídas'' para \"112,3 MB seriam baixados''. Isso indica que os substitutos dos servidores substitutos configurados são utilizáveis e serão baixados, quando possível, para construções futuras."

msgid "substitutes, how to disable"
msgstr "substitutos, como desabilitar"

msgid "The substitute mechanism can be disabled globally by running @code{guix-daemon} with @option{--no-substitutes} (@pxref{Invoking guix-daemon}).  It can also be disabled temporarily by passing the @option{--no-substitutes} option to @command{guix package}, @command{guix build}, and other command-line tools."
msgstr "O mecanismo de substituição pode ser desabilitado globalmente executando @code{guix-daemon} com @option{--no-substitutes} (@pxref{Invoking guix-daemon}). Ele também pode ser desabilitado temporariamente passando a opção @option{--no-substitutes} para @command{guix package}, @command{guix build} e outras ferramentas de linha de comando."

msgid "substitute servers, adding more"
msgstr "servidores substitutos, adicionando mais"

msgid "Guix can look up and fetch substitutes from several servers.  This is useful when you are using packages from additional channels for which the official server does not have substitutes but another server provides them.  Another situation where this is useful is when you would prefer to download from your organization's substitute server, resorting to the official server only as a fallback or dismissing it altogether."
msgstr "Guix pode procurar e buscar substitutos de vários servidores. Isso é útil quando você está usando pacotes de canais adicionais para os quais o servidor oficial não tem substitutos, mas outro servidor os fornece. Outra situação em que isso é útil é quando você prefere baixar do servidor substituto da sua organização, recorrendo ao servidor oficial apenas como um fallback ou descartando-o completamente."

msgid "You can give Guix a list of substitute server URLs and it will check them in the specified order.  You also need to explicitly authorize the public keys of substitute servers to instruct Guix to accept the substitutes they sign."
msgstr "Você pode dar ao Guix uma lista de URLs de servidores substitutos e ele irá verificá-los na ordem especificada. Você também precisa autorizar explicitamente as chaves públicas dos servidores substitutos para instruir o Guix a aceitar os substitutos que eles assinam."

msgid "On Guix System, this is achieved by modifying the configuration of the @code{guix} service.  Since the @code{guix} service is part of the default lists of services, @code{%base-services} and @code{%desktop-services}, you can use @code{modify-services} to change its configuration and add the URLs and substitute keys that you want (@pxref{Service Reference, @code{modify-services}})."
msgstr "No Guix System, isso é obtido modificando a configuração do serviço @code{guix}. Como o serviço @code{guix} faz parte das listas padrão de serviços, @code{%base-services} e @code{%desktop-services}, você pode usar @code{modify-services} para alterar sua configuração e adicionar as URLs e chaves substitutas que você deseja (@pxref{Service Reference, @code{modify-services}})."

msgid "As an example, suppose you want to fetch substitutes from @code{guix.example.org} and to authorize the signing key of that server, in addition to the default @code{@value{SUBSTITUTE-SERVER-1}} and @code{@value{SUBSTITUTE-SERVER-2}}.  The resulting operating system configuration will look something like:"
msgstr "Como exemplo, suponha que você queira buscar substitutos de @code{guix.example.org} e autorizar a chave de assinatura desse servidor, além do padrão @code{@value{SUBSTITUTE-SERVER-1}} e @code{@value{SUBSTITUTE-SERVER-2}}. A configuração do sistema operacional resultante será algo como:"

msgid ""
"(operating-system\n"
"  ;; @dots{}\n"
"  (services\n"
"    ;; Assume we're starting from '%desktop-services'.  Replace it\n"
"    ;; with the list of services you're actually using.\n"
"    (modify-services %desktop-services\n"
"      (guix-service-type config =>\n"
"                        (guix-configuration\n"
"                          (inherit config)\n"
"                          (substitute-urls\n"
"                            (append (list \"https://guix.example.org\")\n"
"                                    %default-substitute-urls))\n"
"                          (authorized-keys\n"
"                            (append (list (local-file \"./key.pub\"))\n"
"                                    %default-authorized-guix-keys)))))))\n"
msgstr ""
"(operating-system\n"
" ;; @dots{}\n"
" (services\n"
"  ;; Suponha que estamos começando com '%desktop-services'. Substitua-o\n"
"  ;; pela lista de serviços que você está realmente usando.\n"
"  (modify-services %desktop-services\n"
"    (guix-service-type config =>\n"
"                       (guix-configuration\n"
"                        (inherit config)\n"
"                        (substitute-urls\n"
"                         (append (list \"https://guix.example.org\")\n"
"                                 %default-substitute-urls))\n"
"                        (authorized-keys\n"
"                         (append (list (local-file \"./key.pub\"))\n"
"                                 %default-authorized-guix-keys)))))))\n"

msgid "This assumes that the file @file{key.pub} contains the signing key of @code{guix.example.org}.  With this change in place in your operating system configuration file (say @file{/etc/config.scm}), you can reconfigure and restart the @code{guix-daemon} service or reboot so the changes take effect:"
msgstr "Isso pressupõe que o arquivo @file{key.pub} contém a chave de assinatura de @code{guix.example.org}. Com essa alteração em vigor no arquivo de configuração do seu sistema operacional (digamos @file{/etc/config.scm}), você pode reconfigurar e reiniciar o serviço @code{guix-daemon} ou reinicializar para que as alterações entrem em vigor:"

msgid ""
"$ sudo guix system reconfigure /etc/config.scm\n"
"$ sudo herd restart guix-daemon\n"
msgstr ""
"$ sudo guix system reconfigure /etc/config.scm\n"
"$ sudo herd restart guix-daemon\n"

msgid "If you're running Guix on a ``foreign distro'', you would instead take the following steps to get substitutes from additional servers:"
msgstr "Se você estiver executando o Guix em uma \"distribuição estrangeira'', você deve seguir os seguintes passos para obter substitutos de servidores adicionais:"

msgid "Edit the service configuration file for @code{guix-daemon}; when using systemd, this is normally @file{/etc/systemd/system/guix-daemon.service}.  Add the @option{--substitute-urls} option on the @command{guix-daemon} command line and list the URLs of interest (@pxref{daemon-substitute-urls, @code{guix-daemon --substitute-urls}}):"
msgstr "Edite o arquivo de configuração de serviço para @code{guix-daemon}; ao usar systemd, normalmente é @file{/etc/systemd/system/guix-daemon.service}. Adicione a opção @option{--substitute-urls} na linha de comando @command{guix-daemon} e liste as URLs de interesse (@pxref{daemon-substitute-urls, @code{guix-daemon --substitute-urls}}):"

msgid "@dots{} --substitute-urls='https://guix.example.org @value{SUBSTITUTE-URLS}'\n"
msgstr "@dots{} --substitute-urls='https://guix.example.org @value{SUBSTITUTE-URLS}'\n"

msgid "Restart the daemon.  For systemd, it goes like this:"
msgstr "Reinicie o daemon. Para systemd, é assim:"

msgid ""
"systemctl daemon-reload\n"
"systemctl restart guix-daemon.service\n"
msgstr ""
"systemctl daemon-reload\n"
"systemctl restart guix-daemon.service\n"

msgid "Authorize the key of the new server (@pxref{Invoking guix archive}):"
msgstr "Autorize a chave do novo servidor (@pxref{Invoking guix archive}):"

msgid "guix archive --authorize < key.pub\n"
msgstr "guix archive --authorize < key.pub\n"

msgid "Again this assumes @file{key.pub} contains the public key that @code{guix.example.org} uses to sign substitutes."
msgstr "Novamente, isso pressupõe que @file{key.pub} contém a chave pública que @code{guix.example.org} usa para assinar substitutos."

msgid "Now you're all set! Substitutes will be preferably taken from @code{https://guix.example.org}, using @code{@value{SUBSTITUTE-SERVER-1}} then @code{@value{SUBSTITUTE-SERVER-2}} as fallback options.  Of course you can list as many substitute servers as you like, with the caveat that substitute lookup can be slowed down if too many servers need to be contacted."
msgstr "Agora você está pronto! Os substitutos serão preferencialmente retirados de @code{https://guix.example.org}, usando @code{@value{SUBSTITUTE-SERVER-1}} e então @code{@value{SUBSTITUTE-SERVER-2}} como opções de fallback. Claro que você pode listar quantos servidores substitutos quiser, com a ressalva de que a pesquisa de substitutos pode ser desacelerada se muitos servidores precisarem ser contatados."

msgid "To diagnose problems, you can run @command{guix weather}.  For example, running:"
msgstr "Para diagnosticar problemas, você pode executar @command{guix weather}. Por exemplo, executando:"

msgid "not only tells you which of the currently-configured servers has substitutes for the @code{coreutils} package, it also reports whether one of these servers is unauthorized.  @xref{Invoking guix weather}, for more information."
msgstr "não apenas informa qual dos servidores atualmente configurados tem substitutos para o pacote @code{coreutils}, mas também informa se um desses servidores não está autorizado. @xref{Invoking guix weather}, para mais informações."

msgid "Note that there are also situations where one may want to add the URL of a substitute server @emph{without} authorizing its key.  @xref{Substitute Authentication}, to understand this fine point."
msgstr "Observe que também há situações em que é possível adicionar a URL de um servidor substituto @emph{sem} autorizar sua chave. @xref{Substitute Authentication}, para entender esse ponto."

msgid "digital signatures"
msgstr "assinaturas digitais"

msgid "Guix detects and raises an error when attempting to use a substitute that has been tampered with.  Likewise, it ignores substitutes that are not signed, or that are not signed by one of the keys listed in the ACL."
msgstr "Guix detecta e gera um erro ao tentar usar um substituto que foi adulterado. Da mesma forma, ele ignora substitutos que não são assinados, ou que não são assinados por uma das chaves listadas na ACL."

msgid "There is one exception though: if an unauthorized server provides substitutes that are @emph{bit-for-bit identical} to those provided by an authorized server, then the unauthorized server becomes eligible for downloads.  For example, assume we have chosen two substitute servers with this option:"
msgstr "Há uma exceção, no entanto: se um servidor não autorizado fornecer substitutos que sejam @emph{bit-for-bit idênticos} aos fornecidos por um servidor autorizado, então o servidor não autorizado se torna elegível para downloads. Por exemplo, suponha que escolhemos dois servidores substitutos com esta opção:"

msgid "--substitute-urls=\"https://a.example.org https://b.example.org\"\n"
msgstr "--substitute-urls=\"https://a.example.org https://b.example.org\"\n"

msgid "If the ACL contains only the key for @samp{b.example.org}, and if @samp{a.example.org} happens to serve the @emph{exact same} substitutes, then Guix will download substitutes from @samp{a.example.org} because it comes first in the list and can be considered a mirror of @samp{b.example.org}.  In practice, independent build machines usually produce the same binaries, thanks to bit-reproducible builds (see below)."
msgstr "Se a ACL contiver apenas a chave para @samp{b.example.org}, e se @samp{a.example.org} servir os substitutos @emph{exatamente os mesmos}, então o Guix baixará os substitutos de @samp{a.example.org} porque ele vem primeiro na lista e pode ser considerado um espelho de @samp{b.example.org}. Na prática, máquinas de construção independentes geralmente produzem os mesmos binários, graças às construções reproduzíveis em bits (veja abaixo)."

msgid "When using HTTPS, the server's X.509 certificate is @emph{not} validated (in other words, the server is not authenticated), contrary to what HTTPS clients such as Web browsers usually do.  This is because Guix authenticates substitute information itself, as explained above, which is what we care about (whereas X.509 certificates are about authenticating bindings between domain names and public keys)."
msgstr "Ao usar HTTPS, o certificado X.509 do servidor é @emph{não} validado (em outras palavras, o servidor não é autenticado), ao contrário do que os clientes HTTPS, como navegadores da Web, geralmente fazem. Isso ocorre porque o Guix autentica as próprias informações substitutas, conforme explicado acima, que é o que nos importa (enquanto os certificados X.509 são sobre autenticação de ligações entre nomes de domínio e chaves públicas)."

msgid "Substitutes are downloaded over HTTP or HTTPS@.  The @env{http_proxy} and @env{https_proxy} environment variables can be set in the environment of @command{guix-daemon} and are honored for downloads of substitutes.  Note that the value of those environment variables in the environment where @command{guix build}, @command{guix package}, and other client commands are run has @emph{absolutely no effect}."
msgstr "Os substitutos são baixados por HTTP ou HTTPS@. As variáveis de ambiente @env{http_proxy} e @env{https_proxy} podem ser definidas no ambiente de @command{guix-daemon} e são honradas para downloads de substitutos. Observe que o valor dessas variáveis de ambiente no ambiente onde @command{guix build}, @command{guix package} e outros comandos de cliente são executados não tem @emph{absolutamente nenhum efeito}."

msgid "Even when a substitute for a derivation is available, sometimes the substitution attempt will fail.  This can happen for a variety of reasons: the substitute server might be offline, the substitute may recently have been deleted, the connection might have been interrupted, etc."
msgstr "Mesmo quando um substituto para uma derivação estiver disponível, às vezes a tentativa de substituição falhará. Isso pode acontecer por vários motivos: o servidor substituto pode estar offline, o servidor substituto pode ter sido excluído recentemente, a conexão pode ter sido interrompida, etc."

msgid "When substitutes are enabled and a substitute for a derivation is available, but the substitution attempt fails, Guix will attempt to build the derivation locally depending on whether or not @option{--fallback} was given (@pxref{fallback-option,, common build option @option{--fallback}}).  Specifically, if @option{--fallback} was omitted, then no local build will be performed, and the derivation is considered to have failed.  However, if @option{--fallback} was given, then Guix will attempt to build the derivation locally, and the success or failure of the derivation depends on the success or failure of the local build.  Note that when substitutes are disabled or no substitute is available for the derivation in question, a local build will @emph{always} be performed, regardless of whether or not @option{--fallback} was given."
msgstr "Quando os substitutos estão habilitados e um substituto para uma derivação está disponível, mas a tentativa de substituição falha, o Guix tentará construir a derivação localmente dependendo se @option{--fallback} foi fornecido ou não (@pxref{fallback-option,, opção de compilação comum @option{--fallback}}). Especificamente, se @option{--fallback} for omitido, nenhuma construção local será executada e a derivação será considerada como tendo falhado. No entanto, se @option{--fallback} for fornecido, o Guix tentará construir a derivação localmente, e o sucesso ou fracasso da derivação dependerá do sucesso ou fracasso da construção local. Observe que quando os substitutos estão desabilitados ou nenhum substituto está disponível para a derivação em questão, uma construção local @emph{sempre} será executada, independentemente de @option{--fallback} ter sido fornecido ou não."

msgid "To get an idea of how many substitutes are available right now, you can try running the @command{guix weather} command (@pxref{Invoking guix weather}).  This command provides statistics on the substitutes provided by a server."
msgstr "Para ter uma ideia de quantos substitutos estão disponíveis no momento, você pode tentar executar o comando @command{guix weather} (@pxref{Invoking guix weather}). Este comando fornece estatísticas sobre os substitutos fornecidos por um servidor."

msgid "trust, of pre-built binaries"
msgstr "confiança, de binários pré-construídos"

msgid "Today, each individual's control over their own computing is at the mercy of institutions, corporations, and groups with enough power and determination to subvert the computing infrastructure and exploit its weaknesses.  While using substitutes can be convenient, we encourage users to also build on their own, or even run their own build farm, such that the project run substitute servers are less of an interesting target.  One way to help is by publishing the software you build using @command{guix publish} so that others have one more choice of server to download substitutes from (@pxref{Invoking guix publish})."
msgstr "Hoje, o controlo de cada indivíduo sobre a sua própria computação está à mercê de instituições, empresas e grupos com poder e determinação suficientes para subverter a infra-estrutura informática e explorar as suas fraquezas. Embora o uso de substitutos possa ser conveniente, encorajamos os usuários a também construírem por conta própria, ou até mesmo executarem seu próprio build farm, de modo que os servidores substitutos executados pelo projeto sejam um alvo menos interessante. Uma maneira de ajudar é publicando o software que você constrói usando @command{guix publish} para que outros tenham mais uma opção de servidor para baixar substitutos (@pxref{Invoking guix publish})."

msgid "In the future, we want Guix to have support to publish and retrieve binaries to/from other users, in a peer-to-peer fashion.  If you would like to discuss this project, join us on @email{guix-devel@@gnu.org}."
msgstr "No futuro, queremos que o Guix tenha suporte para publicação e recuperação de binários de/para outros usuários, de forma peer-to-peer. Se você gostaria de discutir este projeto, entre em contato conosco em @email{guix-devel@@gnu.org}."

msgid "multiple-output packages"
msgstr "multiple-output packages"

msgid "package outputs"
msgstr "saídas de pacote"

msgid "outputs"
msgstr "saídas"

msgid "Often, packages defined in Guix have a single @dfn{output}---i.e., the source package leads to exactly one directory in the store.  When running @command{guix install glibc}, one installs the default output of the GNU libc package; the default output is called @code{out}, but its name can be omitted as shown in this command.  In this particular case, the default output of @code{glibc} contains all the C header files, shared libraries, static libraries, Info documentation, and other supporting files."
msgstr "Frequentemente, os pacotes definidos no Guix têm uma única @dfn{saída} --- ou seja, o pacote fonte leva a exatamente um diretório no armazém. Ao executar @command{guix install glibc}, instala-se a saída padrão do pacote GNU libc; A saída padrão é chamada @code{out}, mas seu nome pode ser omitido conforme mostrado neste comando. Neste caso específico, a saída padrão de @code{glibc} contém todos os arquivos de cabeçalho C, bibliotecas compartilhadas, bibliotecas estáticas, documentação de informações e outros arquivos de suporte."

msgid "Sometimes it is more appropriate to separate the various types of files produced from a single source package into separate outputs.  For instance, the GLib C library (used by GTK+ and related packages)  installs more than 20 MiB of reference documentation as HTML pages.  To save space for users who do not need it, the documentation goes to a separate output, called @code{doc}.  To install the main GLib output, which contains everything but the documentation, one would run:"
msgstr "Às vezes é mais apropriado separar os vários tipos de arquivos produzidos a partir de um único pacote fonte em saídas separadas. Por exemplo, a biblioteca GLib C (usada pelo GTK+ e pacotes relacionados) instala mais de 20 MiB de documentação de referência como páginas HTML. Para economizar espaço para usuários que não precisam, a documentação vai para uma saída separada, chamada @code{doc}. Para instalar a saída principal do GLib, que contém tudo menos a documentação, seria executado:"

msgid "guix install glib\n"
msgstr "guix install glib\n"

msgid "The command to install its documentation is:"
msgstr "O comando para instalar sua documentação é:"

msgid "guix install glib:doc\n"
msgstr "guix install glib:doc\n"

msgid "While the colon syntax works for command-line specification of package outputs, it will not work when using a package @emph{variable} in Scheme code.  For example, to add the documentation of @code{glib} to the globally installed packages of an @code{operating-system} (see @ref{operating-system Reference}), a list of two items, the first one being the package @emph{variable} and the second one the name of the output to select (a string), must be used instead:"
msgstr "Embora a sintaxe de dois pontos funcione para especificação de linha de comando de saídas de pacotes, ela não funcionará ao usar uma @emph{variável} de pacote no código do Scheme. Por exemplo, para adicionar a documentação do @code{glib} aos pacotes instalados globalmente de um @code{operating-system} (veja @ref{operating-system Reference}), uma lista de dois itens, sendo o primeiro a @emph{variável} de pacote e o segundo o nome da saída a ser selecionada (uma string), devem ser usados:"

msgid ""
"(use-modules (gnu packages glib))\n"
";; glib-with-documentation is the Guile symbol for the glib package\n"
"(operating-system\n"
" ...\n"
" (packages\n"
"  (append\n"
"   (list (list glib-with-documentation \"doc\"))\n"
"         %base-packages)))\n"
msgstr ""
"(use-modules (gnu packages glib))\n"
";; glib-with-documentation é o símbolo de Guile para o pacote glib\n"
"(operating-system\n"
" ...\n"
" (packages\n"
"  (append\n"
"   (list (list glib-with-documentation \"doc\"))\n"
"         %base-packages)))\n"

msgid "Some packages install programs with different ``dependency footprints''.  For instance, the WordNet package installs both command-line tools and graphical user interfaces (GUIs).  The former depend solely on the C library, whereas the latter depend on Tcl/Tk and the underlying X libraries.  In this case, we leave the command-line tools in the default output, whereas the GUIs are in a separate output.  This allows users who do not need the GUIs to save space.  The @command{guix size} command can help find out about such situations (@pxref{Invoking guix size}).  @command{guix graph} can also be helpful (@pxref{Invoking guix graph})."
msgstr "Alguns pacotes instalam programas com diferentes \"pegadas de dependência''. Por exemplo, o pacote WordNet instala ferramentas de linha de comando e interfaces gráficas de usuário (GUIs). Os primeiros dependem exclusivamente da biblioteca C, enquanto os últimos dependem apenas do Tcl/Tk e das bibliotecas X subjacentes. Nesse caso, deixamos as ferramentas de linha de comando na saída padrão, enquanto as GUIs ficam em uma saída separada. Isso permite que usuários que não precisam de GUIs economizem espaço. O comando @command{guix size} pode ajudar a descobrir tais situações (@pxref{Invoking guix size}). @command{guix graph} também pode ser útil (@pxref{Invoking guix graph})."

msgid "There are several such multiple-output packages in the GNU distribution.  Other conventional output names include @code{lib} for libraries and possibly header files, @code{bin} for stand-alone programs, and @code{debug} for debugging information (@pxref{Installing Debugging Files}).  The outputs of a package are listed in the third column of the output of @command{guix package --list-available} (@pxref{Invoking guix package})."
msgstr "Existem vários desses pacotes de múltiplas saídas na distribuição GNU. Outros nomes de saída convencionais incluem @code{lib} para bibliotecas e possivelmente arquivos de cabeçalho, @code{bin} para programas independentes e @code{debug} para informações de depuração (@pxref{Installing Debugging Files}). A saída de um pacote está listada na terceira coluna da saída de @command{guix package --list-available} (@pxref{Invoking guix package})."

msgid "Invoking @command{guix locate}"
msgstr "Invocando @command{guix locate}"

msgid "There's so much free software out there that sooner or later, you will need to search for packages.  The @command{guix search} command that we've seen before (@pxref{Invoking guix package}) lets you search by keywords:"
msgstr "Há tantos softwares gratuitos por aí que, mais cedo ou mais tarde, você precisará procurar por pacotes. O comando @command{guix search} que vimos antes (@pxref{Invoking guix package}) permite pesquisar por palavras-chave:"

msgid "guix search video editor\n"
msgstr "guix search video editor\n"

msgid "searching for packages, by file name"
msgstr "procurando por pacotes, por nome de arquivo"

msgid "Sometimes, you instead want to find which package provides a given file, and this is where @command{guix locate} comes in.  Here is how you can find which package provides the @command{ls} command:"
msgstr "Às vezes, você deseja descobrir qual pacote fornece um determinado arquivo, e é aí que entra @command{guix locate}. Veja como você pode encontrar o comando @command{ls}:"

msgid ""
"$ guix locate ls\n"
"coreutils@@9.1       /gnu/store/@dots{}-coreutils-9.1/bin/ls\n"
msgstr ""
"$ guix locate ls\n"
"coreutils@@9.1       /gnu/store/@dots{}-coreutils-9.1/bin/ls\n"

msgid "Of course the command works for any file, not just commands:"
msgstr "É claro que o comando funciona para qualquer arquivo, não apenas para comandos:"

msgid ""
"$ guix locate unistr.h\n"
"icu4c@@71.1          /gnu/store/@dots{}/include/unicode/unistr.h\n"
"libunistring@@1.0    /gnu/store/@dots{}/include/unistr.h\n"
msgstr ""
"$ guix locate unistr.h\n"
"icu4c@@71.1          /gnu/store/@dots{}/include/unicode/unistr.h\n"
"libunistring@@1.0    /gnu/store/@dots{}/include/unistr.h\n"

msgid "You may also specify @dfn{glob patterns} with wildcards.  For example, here is how you would search for packages providing @file{.service} files:"
msgstr "Você também pode especificar @dfn{padrões de globo} com curingas. Por exemplo, aqui está como você procuraria pacotes que fornecem arquivos @file{.service}:"

msgid "The @command{guix locate} command relies on a database that maps file names to package names.  By default, it automatically creates that database if it does not exist yet by traversing packages available @emph{locally}, which can take a few minutes (depending on the size of your store and the speed of your storage device)."
msgstr "O comando @command{guix locate} depende de um banco de dados que mapeia nomes de arquivos para nomes de pacotes. Por padrão, ele cria automaticamente esse banco de dados, caso ele ainda não exista, percorrendo os pacotes disponíveis @emph{localmente}, o que pode levar alguns minutos (dependendo do tamanho do seu armazém e da velocidade do seu dispositivo de armazenamento)."

msgid "For now, @command{guix locate} builds its database based on purely local knowledge---meaning that you will not find packages that never reached your store.  Eventually it will support downloading a pre-built database so you can potentially find more packages."
msgstr "Por enquanto, @command{guix locate} constrói seu banco de dados baseado em conhecimento puramente local – o que significa que você não encontrará pacotes que nunca chegaram ao sue armazém. Eventualmente, ele suportará o download de um banco de dados pré-construído para que você possa encontrar mais pacotes."

msgid "By default, @command{guix locate} first tries to look for a system-wide database, usually under @file{/var/cache/guix/locate}; if it does not exist or is too old, it falls back to the per-user database, by default under @file{~/.cache/guix/locate}.  On a multi-user system, administrators may want to periodically update the system-wide database so that all users can benefit from it, for instance by setting up @code{package-database-service-type} (@pxref{File Search Services, @code{package-database-service-type}})."
msgstr "Por padrão, @command{guix locate} primeiro tenta procurar um banco de dados de todo o sistema, geralmente em @file{/var/cache/guix/locate}; Se não existir ou for muito antigo, ele retornará ao banco de dados por usuário, por padrão em @file{~/.cache/guix/locate}. Em um sistema multiusuário, os administradores podem querer atualizar periodicamente o banco de dados de todo o sistema para que todos os usuários possam se beneficiar dele, por exemplo, configurando @code{package-database-service-type} (@pxref{File Search Services, @code{package-database-service-type}})."

msgid "The general syntax is:"
msgstr "A sintaxe geral é:"

msgid "guix locate [@var{options}@dots{}] @var{file}@dots{}\n"
msgstr "guix locate [@var{opções}@dots{}] @var{arquivo}@dots{}\n"

msgid "... where @var{file} is the name of a file to search for (specifically, the ``base name'' of the file: files whose parent directories are called @var{file} are not matched)."
msgstr "... onde @var{arquivo} é o nome de um arquivo a ser pesquisado (especificamente, o \"nome base\" do arquivo: arquivos cujos diretórios pais são chamados @var{arquivo} não são correspondidos)."

msgid "The available options are as follows:"
msgstr "As opções disponíveis são as seguintes:"

msgid "--glob"
msgstr "--glob"

msgid "-g"
msgstr "-g"

msgid "Interpret @var{file}@dots{} as @dfn{glob patterns}---patterns that may include wildcards, such as @samp{*.scm} to denote all files ending in @samp{.scm}."
msgstr "Interprete @var{arquivo}@dots{} como @dfn{padrões de globo}---padrões que podem incluir caracteres curinga, como @samp{*.scm} para denotar todos os arquivos que terminam em @samp{.scm}."

msgid "--stats"
msgstr "--stats"

msgid "Display database statistics."
msgstr "Exibir estatísticas do banco de dados."

msgid "--update"
msgstr "--update"

msgid "-u"
msgstr "-u"

msgid "Update the file database."
msgstr "Atualize o banco de dados dos arquivos."

msgid "By default, the database is automatically updated when it is too old."
msgstr "Por padrão, o banco de dados é atualizado automaticamente quando é muito antigo."

msgid "--clear"
msgstr "--clear"

msgid "Clear the database and re-populate it."
msgstr "Limpe o banco de dados e preencha-o novamente."

msgid "This option lets you start anew, ensuring old data is removed from the database, which also avoids having an endlessly growing database.  By default @command{guix locate} automatically does that periodically, though infrequently."
msgstr "Esta opção permite começar de novo, garantindo que os dados antigos sejam removidos do banco de dados, o que também evita ter um banco de dados em constante crescimento. Por padrão, @command{guix locate} faz isso automaticamente periodicamente, embora com pouca frequência."

msgid "--database=@var{file}"
msgstr "--database=@var{arquivo}"

msgid "Use @var{file} as the database, creating it if necessary."
msgstr "Use @var{arquivo} como banco de dados, criando-o se necessário."

msgid "By default, @command{guix locate} picks the database under @file{~/.cache/guix} or @file{/var/cache/guix}, whichever is the most recent one."
msgstr "Por padrão, @command{guix locate} escolhe o banco de dados em @file{~/.cache/guix} ou @file{/var/cache/guix}, o que for mais recente."

msgid "--method=@var{method}"
msgstr "--method=@var{método}"

msgid "-m @var{method}"
msgstr "-m @var{método}"

msgid "Use @var{method} to select the set of packages to index.  Possible values are:"
msgstr "Use @var{método} para selecionar o conjunto de pacotes a serem indexados. Os valores possíveis são:"

msgid "manifests"
msgstr "manifests"

msgid "This is the default method: it works by traversing profiles on the machine and recording packages it encounters---packages you or other users of the machine installed, directly or indirectly.  It is fast but it can miss other packages available in the store but not referred to by any profile."
msgstr "Este é o método padrão: ele funciona percorrendo perfis na máquina e gravando os pacotes que encontra – pacotes instalados por você ou por outros usuários da máquina, direta ou indiretamente. É rápido mas você pode perder outros pacotes disponíveis no armazém mas não referenciados por nenhum perfil."

msgid "This is a slower but more exhaustive method: it checks among all the existing packages those that are available in the store and records them."
msgstr "Este é um método mais lento, porém mais exaustivo: verifica entre todos os pacotes existentes aqueles que estão disponíveis no armazém e os registra."

msgid "Invoking @command{guix gc}"
msgstr "Invocando @command{guix gc}"

msgid "garbage collector"
msgstr "coletor de lixo"

msgid "disk space"
msgstr "espaço em disco"

msgid "guix gc"
msgstr "guix gc"

msgid "Packages that are installed, but not used, may be @dfn{garbage-collected}.  The @command{guix gc} command allows users to explicitly run the garbage collector to reclaim space from the @file{/gnu/store} directory.  It is the @emph{only} way to remove files from @file{/gnu/store}---removing files or directories manually may break it beyond repair!"
msgstr "Pacotes instalados mas não usados podem ser @dfn{garbage-collected}. O comando @command{guix gc} permite que os usuários executem explicitamente o coletor de lixo para recuperar espaço do diretório @file{/gnu/store}. É a maneira @emph{única} de remover arquivos de @file{/gnu/store} --- remover arquivos ou diretórios manualmente pode quebrá-los sem possibilidade de reparo!"

msgid "The garbage collector has a set of known @dfn{roots}: any file under @file{/gnu/store} reachable from a root is considered @dfn{live} and cannot be deleted; any other file is considered @dfn{dead} and may be deleted.  The set of garbage collector roots (``GC roots'' for short)  includes default user profiles; by default, the symlinks under @file{/var/guix/gcroots} represent these GC roots.  New GC roots can be added with @command{guix build --root}, for example (@pxref{Invoking guix build}).  The @command{guix gc --list-roots} command lists them."
msgstr "O coletor de lixo possui um conjunto de @dfn{raizes} conhecidos: qualquer arquivo em @file{/gnu/store} acessível a partir de uma raiz é considerado @dfn{live} e não pode ser excluído; Qualquer outro arquivo é considerado @dfn{dead} e pode ser excluído. O conjunto de raízes do coletor de lixo (abreviadamente ``Raízes GC'') inclui perfis de usuário padrão; por padrão, as ligações simbólicas em @file{/var/guix/gcroots} representam essas raízes do GC. Novas raízes de GC podem ser adicionadas com @command{guix build --root}, por exemplo (@pxref{Invoking guix build}). O comando @command{guix gc --list-roots} os lista."

msgid "Prior to running @code{guix gc --collect-garbage} to make space, it is often useful to remove old generations from user profiles; that way, old package builds referenced by those generations can be reclaimed.  This is achieved by running @code{guix package --delete-generations} (@pxref{Invoking guix package})."
msgstr "Antes de executar @code{guix gc --collect-garbage} para liberar espaço, geralmente é útil remover gerações antigas dos perfis de usuário; dessa forma, compilações de pacotes antigos referenciadas por essas gerações podem ser recuperadas. Isso é conseguido executando @code{guix package --delete-generations} (@pxref{Invoking guix package})."

msgid "Our recommendation is to run a garbage collection periodically, or when you are short on disk space.  For instance, to guarantee that at least 5@tie{}GB are available on your disk, simply run:"
msgstr "Nossa recomendação é executar uma coleta de lixo periodicamente ou quando houver pouco espaço em disco. Por exemplo, para garantir que pelo menos 5@tie{}GB estejam disponíveis no disco, basta executar:"

msgid "guix gc -F 5G\n"
msgstr "guix gc -F 5G\n"

msgid "It is perfectly safe to run as a non-interactive periodic job (@pxref{Scheduled Job Execution}, for how to set up such a job).  Running @command{guix gc} with no arguments will collect as much garbage as it can, but that is often inconvenient: you may find yourself having to rebuild or re-download software that is ``dead'' from the GC viewpoint but that is necessary to build other pieces of software---e.g., the compiler tool chain."
msgstr "É perfeitamente seguro executar como um trabalho periódico não interativo (@pxref{Scheduled Job Execution}, para saber como configurar tal trabalho). Executar @command{guix gc} sem argumentos coletará o máximo de lixo possível, mas isso geralmente é inconveniente: você pode ter que reconstruir ou baixar novamente um software que está \"morto\" do ponto de vista do GC, mas que é necessário para construir outras peças de software - por exemplo, a cadeia de ferramentas do compilador."

msgid "The @command{guix gc} command has three modes of operation: it can be used to garbage-collect any dead files (the default), to delete specific files (the @option{--delete} option), to print garbage-collector information, or for more advanced queries.  The garbage collection options are as follows:"
msgstr "O comando @command{guix gc} tem três modos de operação: pode ser usado para coletar o lixo de quaisquer arquivos mortos (o padrão), para excluir arquivos específicos (a opção @option{--delete}), para imprimir lixo- informações do coletor ou para consultas mais avançadas. As opções de coleta de lixo são as seguintes:"

msgid "--collect-garbage[=@var{min}]"
msgstr "--collect-garbage[=@var{min}]"

msgid "-C [@var{min}]"
msgstr "-C [@var{min}]"

msgid "Collect garbage---i.e., unreachable @file{/gnu/store} files and sub-directories.  This is the default operation when no option is specified."
msgstr "Colete lixo, ou seja, arquivos e subdiretórios @file{/gnu/store} inacessíveis. Esta é a operação padrão quando nenhuma opção é especificada."

msgid "When @var{min} is given, stop once @var{min} bytes have been collected.  @var{min} may be a number of bytes, or it may include a unit as a suffix, such as @code{MiB} for mebibytes and @code{GB} for gigabytes (@pxref{Block size, size specifications,, coreutils, GNU Coreutils})."
msgstr "Quando @var{min} for fornecido, pare quando @var{min} bytes forem coletados. @var{min} pode ser um número de bytes ou pode incluir uma unidade como sufixo, como @code{MiB} para mebibytes e @code{GB} para gigabytes (@pxref{Block size, especificações de tamanho,, coreutils, GNU Coreutils})."

msgid "When @var{min} is omitted, collect all the garbage."
msgstr "Quando @var{min} for omitido, colete todo o lixo."

msgid "--free-space=@var{free}"
msgstr "--free-space=@var{free}"

msgid "-F @var{free}"
msgstr "-F @var{free}"

msgid "Collect garbage until @var{free} space is available under @file{/gnu/store}, if possible; @var{free} denotes storage space, such as @code{500MiB}, as described above."
msgstr "Colete o lixo até que o espaço @var{free} esteja disponível em @file{/gnu/store}, se possível; @var{free} denota espaço de armazenamento, como @code{500MiB}, conforme descrito acima."

msgid "When @var{free} or more is already available in @file{/gnu/store}, do nothing and exit immediately."
msgstr "Quando @var{free} ou mais já estiver disponível em @file{/gnu/store}, não faça nada e saia imediatamente."

msgid "--delete-generations[=@var{duration}]"
msgstr "--delete-generations[=@var{duração}]"

msgid "-d [@var{duration}]"
msgstr "-d [@var{duração}]"

msgid "Before starting the garbage collection process, delete all the generations older than @var{duration}, for all the user profiles and home environment generations; when run as root, this applies to all the profiles @emph{of all the users}."
msgstr "Antes de iniciar o processo de coleta de lixo, exclua todas as gerações anteriores a @var{duração}, para todos os perfis de usuário e gerações do ambiente pessoal. Quando executado como root, isso se aplica a todos os perfis @emph{de todos os usuários}."

msgid "For example, this command deletes all the generations of all your profiles that are older than 2 months (except generations that are current), and then proceeds to free space until at least 10 GiB are available:"
msgstr "Por exemplo, este comando exclui todas as gerações de todos os seus perfis com mais de 2 meses (exceto as gerações atuais) e depois libera espaço até que pelo menos 10 GiB estejam disponíveis:"

msgid "guix gc -d 2m -F 10G\n"
msgstr "guix gc -d 2m -F 10G\n"

msgid "--delete"
msgstr "--delete"

msgid "-D"
msgstr "-D"

msgid "Attempt to delete all the store files and directories specified as arguments.  This fails if some of the files are not in the store, or if they are still live."
msgstr "Tentativa de excluir todos os arquivos e diretórios de armazém especificados como argumentos. Isso falhará se alguns dos arquivos não estiverem no armazém ou se ainda estiverem ativos."

msgid "--list-failures"
msgstr "--list-failures"

msgid "List store items corresponding to cached build failures."
msgstr "Listar itens de armazém correspondentes a falhas de compilação em cache."

msgid "This prints nothing unless the daemon was started with @option{--cache-failures} (@pxref{Invoking guix-daemon, @option{--cache-failures}})."
msgstr "Isso não imprime nada, a menos que o daemon tenha sido iniciado com @option{--cache-failures} (@pxref{Invoking guix-daemon, @option{--cache-failures}})."

msgid "List the GC roots owned by the user; when run as root, list @emph{all} the GC roots."
msgstr "Listar as raízes do GC de propriedade do usuário; quando executado como root, listar @emph{todas} as raízes do GC."

msgid "List store items in use by currently running processes.  These store items are effectively considered GC roots: they cannot be deleted."
msgstr "Listar itens de armazém em uso por processos em execução no momento. Esses itens de armazém são efetivamente considerados raízes GC: eles não podem ser excluídos."

msgid "--clear-failures"
msgstr "--clear-failures"

msgid "Remove the specified store items from the failed-build cache."
msgstr "Remova os itens de armazém especificados do cache de compilação com falha."

msgid "Again, this option only makes sense when the daemon is started with @option{--cache-failures}.  Otherwise, it does nothing."
msgstr "Novamente, essa opção só faz sentido quando o daemon é iniciado com @option{--cache-failures}. Caso contrário, não faz nada."

msgid "--list-dead"
msgstr "--list-dead"

msgid "Show the list of dead files and directories still present in the store---i.e., files and directories no longer reachable from any root."
msgstr "Exibe a lista de arquivos e diretórios mortos ainda presentes no armazém, ou seja, arquivos e diretórios que não podem mais ser acessados de nenhuma raiz."

msgid "--list-live"
msgstr "--list-live"

msgid "Show the list of live store files and directories."
msgstr "Exibe a lista de arquivos e diretórios do armazém ativa."

msgid "In addition, the references among existing store files can be queried:"
msgstr "Além disso, as referências entre arquivos de armazém existentes podem ser consultadas:"

msgid "--references"
msgstr "--references"

msgid "package dependencies"
msgstr "dependências de pacotes"

msgid "List the references (respectively, the referrers) of store files given as arguments."
msgstr "Listar as referências (respectivamente, os referenciadores) dos arquivos de armazém fornecidos como argumentos."

msgid "--requisites"
msgstr "--requisites"

msgid "closure"
msgstr "closure"

msgid "List the requisites of the store files passed as arguments.  Requisites include the store files themselves, their references, and the references of these, recursively.  In other words, the returned list is the @dfn{transitive closure} of the store files."
msgstr "Liste os requisitos dos arquivos de armazém passados como argumentos. Os requisitos incluem os próprios arquivos de armazém, suas referências e as referências destes, recursivamente. Em outras palavras, a lista retornada é o @dfn{fechamento transitivo} dos arquivos de armazém."

msgid "@xref{Invoking guix size}, for a tool to profile the size of the closure of an element.  @xref{Invoking guix graph}, for a tool to visualize the graph of references."
msgstr "@xref{Invoking guix size}, para uma ferramenta para criar o perfil do tamanho do fechamento de um elemento. @xref{Invoking guix graph}, para uma ferramenta para visualizar o grafo de referências."

msgid "derivation"
msgstr "derivation"

msgid "Return the derivation(s) leading to the given store items (@pxref{Derivations})."
msgstr "Retorna a(s) derivação(ões) que levam aos itens de armazém fornecidos (@pxref{Derivations})."

msgid "For example, this command:"
msgstr "Por exemplo, este comando:"

msgid "guix gc --derivers $(guix package -I ^emacs$ | cut -f4)\n"
msgstr "guix gc --derivers $(guix package -I ^emacs$ | cut -f4)\n"

msgid "returns the @file{.drv} file(s) leading to the @code{emacs} package installed in your profile."
msgstr "retorna o(s) arquivo(s) @file{.drv} que levam ao pacote @code{emacs} instalado no seu perfil."

msgid "Note that there may be zero matching @file{.drv} files, for instance because these files have been garbage-collected.  There can also be more than one matching @file{.drv} due to fixed-output derivations."
msgstr "Note que pode haver zero arquivos @file{.drv} correspondentes, por exemplo porque esses arquivos foram coletados como lixo. Também pode haver mais de um @file{.drv} correspondente devido a derivações de saída fixa."

msgid "Lastly, the following options allow you to check the integrity of the store and to control disk usage."
msgstr "Por fim, as seguintes opções permitem que você verifique a integridade do armazém e controle o uso do disco."

msgid "--verify[=@var{options}]"
msgstr "--verify[=@var{opções}]"

msgid "integrity, of the store"
msgstr "integridade do armazém"

msgid "integrity checking"
msgstr "verificação de integridade"

msgid "Verify the integrity of the store."
msgstr "Verifique a integridade do armazém."

msgid "By default, make sure that all the store items marked as valid in the database of the daemon actually exist in @file{/gnu/store}."
msgstr "Por padrão, certifique-se de que todos os itens de armazém marcados como válidos no banco de dados do daemon realmente existam em @file{/gnu/store}."

msgid "When provided, @var{options} must be a comma-separated list containing one or more of @code{contents} and @code{repair}."
msgstr "Quando fornecido, @var{opções} deve ser uma lista separada por vírgulas contendo um ou mais de @code{contents} e @code{repair}."

msgid "When passing @option{--verify=contents}, the daemon computes the content hash of each store item and compares it against its hash in the database.  Hash mismatches are reported as data corruptions.  Because it traverses @emph{all the files in the store}, this command can take a long time, especially on systems with a slow disk drive."
msgstr "Ao passar @option{--verify=contents}, o daemon calcula o hash de conteúdo de cada item do armazém e o compara com seu hash no banco de dados. Incompatibilidades de hash são relatadas como corrupções de dados. Como ele percorre @emph{todos os arquivos no armazém}, esse comando pode levar muito tempo, especialmente em sistemas com uma unidade de disco lenta."

msgid "repairing the store"
msgstr "consertando o armazém"

msgid "corruption, recovering from"
msgstr "corrupção, recuperando-se de"

msgid "Using @option{--verify=repair} or @option{--verify=contents,repair} causes the daemon to try to repair corrupt store items by fetching substitutes for them (@pxref{Substitutes}).  Because repairing is not atomic, and thus potentially dangerous, it is available only to the system administrator.  A lightweight alternative, when you know exactly which items in the store are corrupt, is @command{guix build --repair} (@pxref{Invoking guix build})."
msgstr "Usar @option{--verify=repair} ou @option{--verify=contents,repair} faz com que o daemon tente reparar itens corrompidos do armazém buscando substitutos para eles (@pxref{Substitutes}). Como o reparo não é atômico e, portanto, potencialmente perigoso, ele está disponível apenas para o administrador do sistema. Uma alternativa leve, quando você sabe exatamente quais itens no armazém estão corrompidos, é @command{guix build --repair} (@pxref{Invoking guix build})."

msgid "--optimize"
msgstr "--optimize"

msgid "Optimize the store by hard-linking identical files---this is @dfn{deduplication}."
msgstr "Otimize o armazém vinculando fisicamente arquivos idênticos — isso é @dfn{deduplication}."

msgid "The daemon performs deduplication after each successful build or archive import, unless it was started with @option{--disable-deduplication} (@pxref{Invoking guix-daemon, @option{--disable-deduplication}}).  Thus, this option is primarily useful when the daemon was running with @option{--disable-deduplication}."
msgstr "O daemon executa a desduplicação após cada importação bem-sucedida de build ou archive, a menos que tenha sido iniciado com @option{--disable-deduplication} (@pxref{Invoking guix-daemon, @option{--disable-deduplication}}). Portanto, essa opção é útil principalmente quando o daemon estava em execução com @option{--disable-deduplication}."

msgid "--vacuum-database"
msgstr "--vacuum-database"

msgid "vacuum the store database"
msgstr "aspirar o banco de dados do armazém"

msgid "Guix uses an sqlite database to keep track of the items in the store (@pxref{The Store}).  Over time it is possible that the database may grow to a large size and become fragmented.  As a result, one may wish to clear the freed space and join the partially used pages in the database left behind from removed packages or after running the garbage collector.  Running @command{sudo guix gc --vacuum-database} will lock the database and @code{VACUUM} the store, defragmenting the database and purging freed pages, unlocking the database when it finishes."
msgstr "Guix usa um banco de dados sqlite para manter o controle dos itens no armazém (@pxref{The Store}). Com o tempo, é possível que o banco de dados cresça muito e se torne fragmentado. Como resultado, pode-se desejar limpar o espaço liberado e juntar as páginas parcialmente usadas no banco de dados deixadas para trás por pacotes removidos ou após executar o coletor de lixo. Executar @command{sudo guix gc --vacuum-database} bloqueará o banco de dados e @code{VACUUM} o store, desfragmentando o banco de dados e expurgando as páginas liberadas, desbloqueando o banco de dados quando terminar."

msgid "Invoking @command{guix pull}"
msgstr "Invocando @command{guix pull}"

msgid "upgrading Guix"
msgstr "atualizando Guix"

msgid "updating Guix"
msgstr "atualizando Guix"

msgid "guix pull"
msgstr "guix pull"

msgid "pull"
msgstr "puxar"

msgid "security, @command{guix pull}"
msgstr "segurança, @command{guix pull}"

msgid "authenticity, of code obtained with @command{guix pull}"
msgstr "autenticidade, do código obtido com @command{guix pull}"

msgid "Packages are installed or upgraded to the latest version available in the distribution currently available on your local machine.  To update that distribution, along with the Guix tools, you must run @command{guix pull}: the command downloads the latest Guix source code and package descriptions, and deploys it.  Source code is downloaded from a @uref{https://git-scm.com/book/en/, Git} repository, by default the official GNU@tie{}Guix repository, though this can be customized.  @command{guix pull} ensures that the code it downloads is @emph{authentic} by verifying that commits are signed by Guix developers."
msgstr "Os pacotes são instalados ou atualizados para a versão mais recente disponível na distribuição atualmente disponível na sua máquina local. Para atualizar essa distribuição, junto com as ferramentas Guix, você deve executar @command{guix pull}: o comando baixa o código-fonte Guix mais recente e as descrições dos pacotes, e os implementa. O código-fonte é baixado de um repositório @uref{https://git-scm.com/book/pt-br/, Git}, por padrão o repositório oficial GNU@tie{}Guix, embora isso possa ser personalizado. @command{guix pull} garante que o código que ele baixa é @emph{autêntico}, verificando se os commits são assinados pelos desenvolvedores Guix."

msgid "Specifically, @command{guix pull} downloads code from the @dfn{channels} (@pxref{Channels}) specified by one of the following, in this order:"
msgstr "Especificamente, @command{guix pull} baixa o código dos @dfn{canais} (@pxref{Canais}) especificados por um dos seguintes, nesta ordem:"

msgid "the @option{--channels} option;"
msgstr "a opção @option{--channels};"

msgid "the user's @file{~/.config/guix/channels.scm} file, unless @option{-q} is passed;"
msgstr "o arquivo @file{~/.config/guix/channels.scm} do usuário, a menos que @option{-q} seja passado;"

msgid "the system-wide @file{/etc/guix/channels.scm} file, unless @option{-q} is passed (on Guix System, this file can be declared in the operating system configuration, @pxref{guix-configuration-channels, @code{channels} field of @code{guix-configuration}});"
msgstr "o arquivo @file{/etc/guix/channels.scm} de todo o sistema, a menos que @option{-q} seja passado (no sistema Guix, este arquivo pode ser declarado na configuração do sistema operacional, @pxref{guix-configuration-channels, campo @code{channels} de @code{guix-configuration}});"

msgid "the built-in default channels specified in the @code{%default-channels} variable."
msgstr "os canais padrão integrados especificados na variável @code{%default-channels}."

msgid "On completion, @command{guix package} will use packages and package versions from this just-retrieved copy of Guix.  Not only that, but all the Guix commands and Scheme modules will also be taken from that latest version.  New @command{guix} sub-commands added by the update also become available."
msgstr "Após a conclusão, @command{guix package} usará pacotes e versões de pacotes desta cópia recém-recuperada do Guix. Não apenas isso, mas todos os comandos Guix e módulos Scheme também serão retirados dessa versão mais recente. Novos subcomandos @command{guix} adicionados pela atualização também se tornam disponíveis."

msgid "Any user can update their Guix copy using @command{guix pull}, and the effect is limited to the user who ran @command{guix pull}.  For instance, when user @code{root} runs @command{guix pull}, this has no effect on the version of Guix that user @code{alice} sees, and vice versa."
msgstr "Qualquer usuário pode atualizar sua cópia do Guix usando @command{guix pull}, e o efeito é limitado ao usuário que executou @command{guix pull}. Por exemplo, quando o usuário @code{root} executa @command{guix pull}, isso não tem efeito na versão do Guix que o usuário @code{alice} vê, e vice-versa."

msgid "The result of running @command{guix pull} is a @dfn{profile} available under @file{~/.config/guix/current} containing the latest Guix."
msgstr "O resultado da execução de @command{guix pull} é um @dfn{perfil} disponível em @file{~/.config/guix/current} contendo o Guix mais recente."

msgid "The @option{--list-generations} or @option{-l} option lists past generations produced by @command{guix pull}, along with details about their provenance:"
msgstr "A opção @option{--list-generations} ou @option{-l} lista gerações anteriores produzidas por @command{guix pull}, juntamente com detalhes sobre sua procedência:"

msgid ""
"$ guix pull -l\n"
"Generation 1\tJun 10 2018 00:18:18\n"
"  guix 65956ad\n"
"    repository URL: https://git.guix.gnu.org/guix.git\n"
"    branch: origin/master\n"
"    commit: 65956ad3526ba09e1f7a40722c96c6ef7c0936fe\n"
"\n"
msgstr ""
"$ guix pull -l\n"
"Geração 1\t10 jun 2018 00:18:18\n"
"  guix 65956ad\n"
"    URL do repositório: https://git.guix.gnu.org/guix.git\n"
"    ramo: origin/master\n"
"    commit: 65956ad3526ba09e1f7a40722c96c6ef7c0936fe\n"
"\n"

msgid ""
"Generation 2\tJun 11 2018 11:02:49\n"
"  guix e0cc7f6\n"
"    repository URL: https://git.guix.gnu.org/guix.git\n"
"    branch: origin/master\n"
"    commit: e0cc7f669bec22c37481dd03a7941c7d11a64f1d\n"
"\n"
msgstr ""
"Geração 2\t11 jun 2018 11:02:49\n"
"  guix e0cc7f6\n"
"    URL do repositório: https://git.guix.gnu.org/guix.git\n"
"    ramo: origin/master\n"
"    commit: e0cc7f669bec22c37481dd03a7941c7d11a64f1d\n"
"\n"

msgid ""
"Generation 3\tJun 13 2018 23:31:07\t(current)\n"
"  guix 844cc1c\n"
"    repository URL: https://git.guix.gnu.org/guix.git\n"
"    branch: origin/master\n"
"    commit: 844cc1c8f394f03b404c5bb3aee086922373490c\n"
msgstr ""
"Geração 3\t13 jun 2018 23:31:07\t(atual)\n"
"  guix 844cc1c\n"
"    URL do repositório: https://git.guix.gnu.org/guix.git\n"
"    ramo: origin/master\n"
"    commit: 844cc1c8f394f03b404c5bb3aee086922373490c\n"

msgid "@xref{Invoking guix describe, @command{guix describe}}, for other ways to describe the current status of Guix."
msgstr "@xref{Invoking guix describe, @command{guix describe}}, para outras maneiras de descrever o status atual do Guix."

msgid "This @code{~/.config/guix/current} profile works exactly like the profiles created by @command{guix package} (@pxref{Invoking guix package}).  That is, you can list generations, roll back to the previous generation---i.e., the previous Guix---and so on:"
msgstr "Este perfil @code{~/.config/guix/current} funciona exatamente como os perfis criados por @command{guix package} (@pxref{Invoking guix package}). Ou seja, você pode listar gerações, reverter para a geração anterior --- ou seja, o Guix anterior --- e assim por diante:"

msgid ""
"$ guix pull --roll-back\n"
"switched from generation 3 to 2\n"
"$ guix pull --delete-generations=1\n"
"deleting /var/guix/profiles/per-user/charlie/current-guix-1-link\n"
msgstr ""
"$ guix pull --roll-back\n"
"trocado da geração 3 para 2\n"
"$ guix pull --delete-generations=1\n"
"excluindo /var/guix/profiles/per-user/charlie/current-guix-1-link\n"

msgid "You can also use @command{guix package} (@pxref{Invoking guix package})  to manage the profile by naming it explicitly:"
msgstr "Você também pode usar @command{guix package} (@pxref{Invoking guix package}) para gerenciar o perfil nomeando-o explicitamente:"

msgid ""
"$ guix package -p ~/.config/guix/current --roll-back\n"
"switched from generation 3 to 2\n"
"$ guix package -p ~/.config/guix/current --delete-generations=1\n"
"deleting /var/guix/profiles/per-user/charlie/current-guix-1-link\n"
msgstr ""
"$ guix package -p ~/.config/guix/current --roll-back\n"
"trocado da geração 3 para 2\n"
"$ guix package -p ~/.config/guix/current --delete-generations=1\n"
"excluindo /var/guix/profiles/per-user/charlie/current-guix-1-link\n"

msgid "The @command{guix pull} command is usually invoked with no arguments, but it supports the following options:"
msgstr "O comando @command{guix pull} geralmente é invocado sem argumentos, mas suporta as seguintes opções:"

msgid "--url=@var{url}"
msgstr "--url=@var{url}"

msgid "--commit=@var{commit}"
msgstr "--commit=@var{commit}"

msgid "--branch=@var{branch}"
msgstr "--branch=@var{ramo}"

msgid "Download code for the @code{guix} channel from the specified @var{url}, at the given @var{commit} (a valid Git commit ID represented as a hexadecimal string or the name of a tag), or @var{branch}."
msgstr "Baixe o código para o canal @code{guix} do @var{url} especificado, no @var{commit} fornecido (um ID de commit Git válido representado como uma string hexadecimal ou o nome de uma tag) ou @var{ramo}."

msgid "@file{channels.scm}, configuration file"
msgstr "@file{channels.scm}, arquivo de configuração"

msgid "configuration file for channels"
msgstr "arquivo de configuração para canais"

msgid "These options are provided for convenience, but you can also specify your configuration in the @file{~/.config/guix/channels.scm} file or using the @option{--channels} option (see below)."
msgstr "Essas opções são fornecidas para sua conveniência, mas você também pode especificar sua configuração no arquivo @file{~/.config/guix/channels.scm} ou usando a opção @option{--channels} (veja abaixo)."

msgid "--channels=@var{file}"
msgstr "--channels=@var{arquivo}"

msgid "-C @var{file}"
msgstr "-C @var{arquivo}"

msgid "Read the list of channels from @var{file} instead of @file{~/.config/guix/channels.scm} or @file{/etc/guix/channels.scm}.  @var{file} must contain Scheme code that evaluates to a list of channel objects.  @xref{Channels}, for more information."
msgstr "Leia a lista de canais de @var{arquivo} em vez de @file{~/.config/guix/channels.scm} ou @file{/etc/guix/channels.scm}. @var{arquivo} deve conter código Scheme que avalia uma lista de objetos de canal. @xref{Channels}, para mais informações."

msgid "--no-channel-files"
msgstr "--no-channel-files"

msgid "-q"
msgstr "-q"

msgid "Inhibit loading of the user and system channel files, @file{~/.config/guix/channels.scm} and @file{/etc/guix/channels.scm}."
msgstr "Inibir o carregamento dos arquivos de canal do usuário e do sistema, @file{~/.config/guix/channels.scm} e @file{/etc/guix/channels.scm}."

msgid "channel news"
msgstr "canal de notícias"

msgid "--news"
msgstr "--news"

msgid "-N"
msgstr "-N"

msgid "Display news written by channel authors for their users for changes made since the previous generation (@pxref{Channels, Writing Channel News}).  When @option{--details} is passed, additionally display new and upgraded packages."
msgstr "Exibir notícias escritas por autores de canais para seus usuários para alterações feitas desde a geração anterior (@pxref{Channels, Escrevendo Notícias de Canal}). Quando @option{--details} é passado, exibir adicionalmente pacotes novos e atualizados."

msgid "You can view that information for previous generations with @command{guix pull -l}."
msgstr "Você pode visualizar essas informações de gerações anteriores com @command{guix pull -l}."

msgid "List all the generations of @file{~/.config/guix/current} or, if @var{pattern} is provided, the subset of generations that match @var{pattern}.  The syntax of @var{pattern} is the same as with @code{guix package --list-generations} (@pxref{Invoking guix package})."
msgstr "Liste todas as gerações de @file{~/.config/guix/current} ou, se @var{padrão} for fornecido, o subconjunto de gerações que correspondem a @var{padrão}. A sintaxe de @var{padrão} é a mesma de @code{guix package --list-generations} (@pxref{Invoking guix package})."

msgid "By default, this prints information about the channels used in each revision as well as the corresponding news entries.  If you pass @option{--details}, it will also print the list of packages added and upgraded in each generation compared to the previous one."
msgstr "Por padrão, isso imprime informações sobre os canais usados em cada revisão, bem como as entradas de notícias correspondentes. Se você passar @option{--details}, ele também imprimirá a lista de pacotes adicionados e atualizados em cada geração em comparação com a anterior."

msgid "--details"
msgstr "--details"

msgid "Instruct @option{--list-generations} or @option{--news} to display more information about the differences between subsequent generations---see above."
msgstr "Instrua @option{--list-generations} ou @option{--news} para exibir mais informações sobre as diferenças entre gerações subsequentes — veja acima."

msgid "Roll back to the previous @dfn{generation} of @file{~/.config/guix/current}---i.e., undo the last transaction."
msgstr "Reverta para a @dfn{geração} anterior de @file{~/.config/guix/current}---ou seja, desfaça a última transação."

msgid "If the current generation matches, it is @emph{not} deleted."
msgstr "Se a geração atual corresponder, ela @emph{não} será excluída."

msgid "@xref{Invoking guix describe}, for a way to display information about the current generation only."
msgstr "@xref{Invoking guix describe}, para uma maneira de exibir informações somente sobre a geração atual."

msgid "Use @var{profile} instead of @file{~/.config/guix/current}."
msgstr "Use @var{perfil} em vez de @file{~/.config/guix/current}."

msgid "--dry-run"
msgstr "--dry-run"

msgid "-n"
msgstr "-n"

msgid "Show which channel commit(s) would be used and what would be built or substituted but do not actually do it."
msgstr "Mostre quais commits de canal seriam usados e o que seria construído ou substituído, mas não faça isso de fato."

msgid "--allow-downgrades"
msgstr "--allow-downgrades"

msgid "Allow pulling older or unrelated revisions of channels than those currently in use."
msgstr "Permitir extrair revisões de canais mais antigas ou não relacionadas às que estão em uso atualmente."

msgid "downgrade attacks, protection against"
msgstr "ataques de downgrade, proteção contra"

msgid "By default, @command{guix pull} protects against so-called ``downgrade attacks'' whereby the Git repository of a channel would be reset to an earlier or unrelated revision of itself, potentially leading you to install older, known-vulnerable versions of software packages."
msgstr "Por padrão, @command{guix pull} protege contra os chamados \"ataques de downgrade'', nos quais o repositório Git de um canal seria redefinido para uma revisão anterior ou não relacionada a si mesmo, potencialmente levando você a instalar versões mais antigas e conhecidas de pacotes de software."

msgid "Make sure you understand its security implications before using @option{--allow-downgrades}."
msgstr "Certifique-se de entender as implicações de segurança antes de usar @option{--allow-downgrades}."

msgid "--disable-authentication"
msgstr "--disable-authentication"

msgid "Allow pulling channel code without authenticating it."
msgstr "Permitir extrair código de canal sem autenticá-lo."

msgid "authentication, of channel code"
msgstr "autenticação, de código de canal"

msgid "By default, @command{guix pull} authenticates code downloaded from channels by verifying that its commits are signed by authorized developers, and raises an error if this is not the case.  This option instructs it to not perform any such verification."
msgstr "Por padrão, @command{guix pull} autentica o código baixado de canais verificando se seus commits são assinados por desenvolvedores autorizados e gera um erro se esse não for o caso. Esta opção o instrui a não executar nenhuma verificação desse tipo."

msgid "Make sure you understand its security implications before using @option{--disable-authentication}."
msgstr "Certifique-se de entender as implicações de segurança antes de usar @option{--disable-authentication}."

msgid "-s @var{system}"
msgstr "-s @var{sistema}"

msgid "Attempt to build for @var{system}---e.g., @code{i686-linux}---instead of the system type of the build host."
msgstr "Tente compilar para @var{sistema}---por exemplo, @code{i686-linux}---em vez do tipo de sistema do host de compilação."

msgid "Use the bootstrap Guile to build the latest Guix.  This option is only useful to Guix developers."
msgstr "Use o bootstrap Guile para construir o Guix mais recente. Esta opção é útil somente para desenvolvedores Guix."

msgid "The @dfn{channel} mechanism allows you to instruct @command{guix pull} which repository and branch to pull from, as well as @emph{additional} repositories containing package modules that should be deployed.  @xref{Channels}, for more information."
msgstr "O mecanismo dos @dfn{canais} permite que você instrua @command{guix pull} de qual repositório e branch extrair, bem como @emph{repositórios adicionais} contendo módulos de pacote que devem ser implantados. @xref{Channels}, para mais informações."

msgid "In addition, @command{guix pull} supports all the common build options (@pxref{Common Build Options})."
msgstr "Além disso, @command{guix pull} suporta todas as opções de compilação comuns (@pxref{Common Build Options})."

msgid "Invoking @command{guix time-machine}"
msgstr "Invocando @command{guix time-machine}"

msgid "guix time-machine"
msgstr "guix time-machine"

msgid "pinning, channels"
msgstr "fixação, canais"

msgid "replicating Guix"
msgstr "replicando Guix"

msgid "reproducibility, of Guix"
msgstr "reprodutibilidade, de Guix"

msgid "The @command{guix time-machine} command provides access to other revisions of Guix, for example to install older versions of packages, or to reproduce a computation in an identical environment.  The revision of Guix to be used is defined by a commit or by a channel description file created by @command{guix describe} (@pxref{Invoking guix describe})."
msgstr "O comando @command{guix time-machine} fornece acesso a outras revisões do Guix, por exemplo, para instalar versões mais antigas de pacotes ou para reproduzir uma computação em um ambiente idêntico. A revisão do Guix a ser usada é definida por um commit ou por um arquivo de descrição de canal criado por @command{guix describe} (@pxref{Invoking guix describe})."

msgid "Let's assume that you want to travel to those days of November 2020 when version 1.2.0 of Guix was released and, once you're there, run the @command{guile} of that time:"
msgstr "Vamos supor que você queira viajar para aqueles dias de novembro de 2020, quando a versão 1.2.0 do Guix foi lançada e, uma vez lá, executar o @command{guile} daquela época:"

msgid ""
"guix time-machine --commit=v1.2.0 -- \\\n"
"  environment -C --ad-hoc guile -- guile\n"
msgstr ""
"guix time-machine --commit=v1.2.0 -- \\\n"
"  environment -C --ad-hoc guile -- guile\n"

msgid "The command above fetches Guix@tie{}1.2.0 (and possibly other channels specified by your @file{channels.scm} configuration files---see below) and runs its @command{guix environment} command to spawn an environment in a container running @command{guile} (@command{guix environment} has since been subsumed by @command{guix shell}; @pxref{Invoking guix shell}).  It's like driving a DeLorean@footnote{If you don't know what a DeLorean is, consider traveling back to the 1980's. (@uref{https://www.imdb.com/title/tt0088763/, Back to the Future (1985)})}! The first @command{guix time-machine} invocation can be expensive: it may have to download or even build a large number of packages; the result is cached though and subsequent commands targeting the same commit are almost instantaneous."
msgstr "O comando acima busca Guix@tie{}1.2.0 (e possivelmente outros canais especificados pelos seus arquivos de configuração @file{channels.scm} --- veja abaixo) e executa seu comando @command{guix environment} para gerar um ambiente em um contêiner executando @command{guile} (@command{guix environment} foi desde então subsumido por @command{guix shell}; @pxref{Invoking guix shell}). É como dirigir um DeLorean@footnote{Se você não sabe o que é um DeLorean, considere viajar de volta para a década de 1980. (@uref{https://www.imdb.com/title/tt0088763/, De Volta para o Futuro (1985)})}! A primeira invocação de @command{guix time-machine} pode ser cara: pode ser necessário baixar ou até mesmo construir um grande número de pacotes; o resultado é armazenado em cache e os comandos subsequentes direcionados ao mesmo commit são quase instantâneos."

msgid "As for @command{guix pull}, in the absence of any options, @command{time-machine} fetches the latest commits of the channels specified in @file{~/.config/guix/channels.scm}, @file{/etc/guix/channels.scm}, or the default channels; the @option{-q} option lets you ignore these configuration files.  The command:"
msgstr "Quanto ao @command{guix pull}, na ausência de quaisquer opções, o @command{time-machine} busca os últimos commits dos canais especificados em @file{~/.config/guix/channels.scm}, @file{/etc/guix/channels.scm}, ou os canais padrão; a opção @option{-q} permite que você ignore esses arquivos de configuração. O comando:"

msgid "guix time-machine -q -- build hello\n"
msgstr "guix time-machine -q -- build hello\n"

msgid "will thus build the package @code{hello} as defined in the main branch of Guix, without any additional channel, which is in general a newer revision of Guix than you have installed.  Time travel works in both directions!"
msgstr "construirá então o pacote @code{hello} conforme definido no branch principal do Guix, sem nenhum canal adicional, que é em geral uma revisão mais nova do Guix do que a que você instalou. A viagem no tempo funciona em ambas as direções!"

msgid "The history of Guix is immutable and @command{guix time-machine} provides the exact same software as they are in a specific Guix revision.  Naturally, no security fixes are provided for old versions of Guix or its channels.  A careless use of @command{guix time-machine} opens the door to security vulnerabilities.  @xref{Invoking guix pull, @option{--allow-downgrades}}."
msgstr "O histórico do Guix é imutável e @command{guix time-machine} fornece exatamente o mesmo software que eles estão em uma revisão específica do Guix. Naturalmente, nenhuma correção de segurança é fornecida para versões antigas do Guix ou seus canais. Um uso descuidado do @command{guix time-machine} abre a porta para vulnerabilidades de segurança. @xref{Invoking guix pull, @option{--allow-downgrades}}."

msgid "@command{guix time-machine} raises an error when attempting to travel to commits older than ``v0.16.0'' (commit @samp{4a0b87f0}), dated Dec.@: 2018.  This is one of the oldest commits supporting the channel mechanism that makes ``time travel'' possible."
msgstr "@command{guix time-machine} gera um erro ao tentar viajar para commits mais antigos que \"v0.16.0\" (commit @samp{4a0b87f0}), datados de Dez.@: 2018. Este é um dos commits mais antigos que oferecem suporte ao mecanismo de canal que torna a \"viagem no tempo\" possível."

msgid "Although it should technically be possible to travel to such an old commit, the ease to do so will largely depend on the availability of binary substitutes.  When traveling to a distant past, some packages may not easily build from source anymore.  One such example are old versions of OpenSSL whose tests would fail after a certain date.  This particular problem can be worked around by running a @dfn{virtual build machine} with its clock set to the right time (@pxref{build-vm, Virtual Build Machines})."
msgstr "Embora seja tecnicamente possível viajar para um commit tão antigo, a facilidade para fazê-lo dependerá em grande parte da disponibilidade de substitutos binários. Ao viajar para um passado distante, alguns pacotes podem não ser mais facilmente construídos a partir da fonte. Um exemplo são as versões antigas do OpenSSL cujos testes falhavam após uma certa data. Esse problema em particular pode ser contornado executando uma @dfn{máquina de construção virtual} com seu relógio ajustado para a hora certa (@pxref{build-vm, Máquinas de Construção Virtual})."

msgid "guix time-machine @var{options}@dots{} -- @var{command} @var {arg}@dots{}\n"
msgstr "guix time-machine @var{opções}@dots{} -- @var{comando} @var {arg}@dots{}\n"

msgid "where @var{command} and @var{arg}@dots{} are passed unmodified to the @command{guix} command of the specified revision.  The @var{options} that define this revision are the same as for @command{guix pull} (@pxref{Invoking guix pull}):"
msgstr "onde @var{comando} e @var{arg}@dots{} são passados sem modificações para o comando @command{guix} da revisão especificada. As @var{opções} que definem esta revisão são as mesmas que para @command{guix pull} (@pxref{Invoking guix pull}):"

msgid "Use the @code{guix} channel from the specified @var{url}, at the given @var{commit} (a valid Git commit ID represented as a hexadecimal string or the name of a tag), or @var{branch}."
msgstr "Use o canal @code{guix} do @var{url} especificado, no @var{commit} fornecido (um ID de commit Git válido representado como uma string hexadecimal ou o nome de uma tag) ou @var{ramo}."

msgid "Read the list of channels from @var{file}.  @var{file} must contain Scheme code that evaluates to a list of channel objects.  @xref{Channels} for more information."
msgstr "Leia a lista de canais de @var{arquivo}. @var{arquivo} deve conter código Scheme que avalia uma lista de objetos de canal. @xref{Channels} para mais informações."

msgid "Thus, @command{guix time-machine -q} is equivalent to the following Bash command, using the ``process substitution'' syntax (@pxref{Process Substitution,,, bash, The GNU Bash Reference Manual}):"
msgstr "Portanto, @command{guix time-machine -q} é equivalente ao seguinte comando Bash, usando a sintaxe \"substituição de processo\" (@pxref{Process Substitution,,, bash, Manual de referência do GNU Bash}):"

msgid "guix time-machine -C <(echo %default-channels) @dots{}\n"
msgstr "guix time-machine -C <(echo %default-channels) @dots{}\n"

msgid "Note that @command{guix time-machine} can trigger builds of channels and their dependencies, and these are controlled by the standard build options (@pxref{Common Build Options})."
msgstr "Observe que @command{guix time-machine} pode acionar compilações de canais e suas dependências, e elas são controladas pelas opções de compilação padrão (@pxref{Common Build Options})."

msgid "If @command{guix time-machine} is executed without any command, it prints the file name of the profile that would be used to execute the command.  This is sometimes useful if you need to get store file name of the profile---e.g., when you want to @command{guix copy} it."
msgstr "Se @command{guix time-machine} for executado sem nenhum comando, ele imprime o nome do arquivo do perfil que seria usado para executar o comando. Isso às vezes é útil se você precisa obter o nome do arquivo de armazém do perfil --- por exemplo, quando você quer @command{guix copy} ele."

msgid "The functionality described here is a ``technology preview'' as of version @value{VERSION}.  As such, the interface is subject to change."
msgstr "A funcionalidade descrita aqui é uma ``prévia de tecnologia'' da versão @value{VERSION}. Como tal, a interface está sujeita a alterações."

msgid "inferiors"
msgstr "inferiores"

msgid "composition of Guix revisions"
msgstr "composição das revisões do Guix"

msgid "Sometimes you might need to mix packages from the revision of Guix you're currently running with packages available in a different revision of Guix.  Guix @dfn{inferiors} allow you to achieve that by composing different Guix revisions in arbitrary ways."
msgstr "Às vezes, você pode precisar misturar pacotes da revisão do Guix que você está executando atualmente com pacotes disponíveis em uma revisão diferente do Guix. Os @dfn{inferiores} do Guix permite que você consiga isso compondo diferentes revisões do Guix de maneiras arbitrárias."

msgid "inferior packages"
msgstr "pacotes inferiores"

msgid "Technically, an ``inferior'' is essentially a separate Guix process connected to your main Guix process through a REPL (@pxref{Invoking guix repl}).  The @code{(guix inferior)} module allows you to create inferiors and to communicate with them.  It also provides a high-level interface to browse and manipulate the packages that an inferior provides---@dfn{inferior packages}."
msgstr "Tecnicamente, um ``inferior'' é essencialmente um processo Guix separado conectado ao seu processo Guix principal por meio de um REPL (@pxref{Invoking guix repl}). O módulo @code{(guix inferior)} permite que você crie inferiores e se comunique com eles. Ele também fornece uma interface de alto nível para navegar e manipular os pacotes que um inferior fornece---@dfn{pacotes inferiores}."

msgid "When combined with channels (@pxref{Channels}), inferiors provide a simple way to interact with a separate revision of Guix.  For example, let's assume you want to install in your profile the current @code{guile} package, along with the @code{guile-json} as it existed in an older revision of Guix---perhaps because the newer @code{guile-json} has an incompatible API and you want to run your code against the old API@.  To do that, you could write a manifest for use by @code{guix package --manifest} (@pxref{Writing Manifests}); in that manifest, you would create an inferior for that old Guix revision you care about, and you would look up the @code{guile-json} package in the inferior:"
msgstr "Quando combinados com canais (@pxref{Channels}), os inferiores fornecem uma maneira simples de interagir com uma revisão separada do Guix. Por exemplo, vamos supor que você queira instalar em seu perfil o pacote @code{guile} atual, junto com o @code{guile-json} como ele existia em uma revisão mais antiga do Guix---talvez porque o mais novo @code{guile-json} tenha uma API incompatível e você queira executar seu código contra a API antiga. Para fazer isso, você pode escrever um manifesto para uso por @code{guix package --manifest} (@pxref{Writing Manifests}); nesse manifesto, você criaria um inferior para aquela revisão antiga do Guix que você se importa, e você procuraria o pacote @code{guile-json} no inferior:"

msgid ""
"(use-modules (guix inferior) (guix channels)\n"
"             (srfi srfi-1))   ;for 'first'\n"
"\n"
msgstr ""
"(use-modules (guix inferior) (guix channels)\n"
"             (srfi srfi-1))   ;para 'first'\n"
"\n"

msgid ""
"(define channels\n"
"  ;; This is the old revision from which we want to\n"
"  ;; extract guile-json.\n"
"  (list (channel\n"
"         (name 'guix)\n"
"         (url \"https://git.guix.gnu.org/guix.git\")\n"
"         (commit\n"
"          \"65956ad3526ba09e1f7a40722c96c6ef7c0936fe\"))))\n"
"\n"
msgstr ""
"(define canais\n"
"  ;; Esta é a revisão antiga da qual queremos\n"
"  ;; extrair guile-json.\n"
"  (list (channel\n"
"         (name 'guix)\n"
"         (url \"https://git.guix.gnu.org/guix.git\")\n"
"         (commit\n"
"          \"65956ad3526ba09e1f7a40722c96c6ef7c0936fe\"))))\n"
"\n"

msgid ""
"(define inferior\n"
"  ;; An inferior representing the above revision.\n"
"  (inferior-for-channels channels))\n"
"\n"
msgstr ""
"(define inferior\n"
"  ;; Um inferior representando a revisão acima.\n"
"  (inferior-for-channels canais))\n"
"\n"

msgid ""
";; Now create a manifest with the current \"guile\" package\n"
";; and the old \"guile-json\" package.\n"
"(packages->manifest\n"
" (list (first (lookup-inferior-packages inferior \"guile-json\"))\n"
"       (specification->package \"guile\")))\n"
msgstr ""
";; Agora crie um manifesto com o pacote \"guile\" atual\n"
";; e o antigo pacote \"guile-json\".\n"
"(packages->manifest\n"
" (list (first (lookup-inferior-packages inferior \"guile-json\"))\n"
"       (specification->package \"guile\")))\n"

msgid "On its first run, @command{guix package --manifest} might have to build the channel you specified before it can create the inferior; subsequent runs will be much faster because the Guix revision will be cached."
msgstr "Na primeira execução, @command{guix package --manifest} pode ter que construir o canal que você especificou antes de poder criar o inferior; execuções subsequentes serão muito mais rápidas porque a revisão do Guix será armazenada em cache."

msgid "The @code{(guix inferior)} module provides the following procedures to open an inferior:"
msgstr "O módulo @code{(guix inferior)} fornece os seguintes procedimentos para abrir um inferior:"

msgid "{Procedure} inferior-for-channels channels [#:cache-directory] [#:ttl]"
msgstr "{Procedimento} inferior-for-channels canais [#:cache-directory] [#:ttl]"

msgid "Return an inferior for @var{channels}, a list of channels.  Use the cache at @var{cache-directory}, where entries can be reclaimed after @var{ttl} seconds.  This procedure opens a new connection to the build daemon."
msgstr "Retorna um inferior para @var{canais}, uma lista de canais. Use o cache em @var{cache-directory}, onde as entradas podem ser recuperadas após @var{ttl} segundos. Este procedimento abre uma nova conexão com o daemon de construção."

msgid "As a side effect, this procedure may build or substitute binaries for @var{channels}, which can take time."
msgstr "Como efeito colateral, esse procedimento pode criar ou substituir binários para @var{canais}, o que pode levar tempo."

msgid "{Procedure} open-inferior directory [#:command \"bin/guix\"]"
msgstr "{Procedimento} open-inferior diretório [#:command \"bin/guix\"]"

msgid "Open the inferior Guix in @var{directory}, running @code{@var{directory}/@var{command} repl} or equivalent.  Return @code{#f} if the inferior could not be launched."
msgstr "Abra o Guix inferior em @var{diretório}, executando o comando @code{@var{diretório}/@var{command} repl} ou equivalente. Retorne @code{#f} se o inferior não puder ser iniciado."

msgid "The procedures listed below allow you to obtain and manipulate inferior packages."
msgstr "Os procedimentos listados abaixo permitem que você obtenha e manipule pacotes inferiores."

msgid "{Procedure} inferior-packages inferior"
msgstr "{Procedimento} inferior-packages inferior"

msgid "Return the list of packages known to @var{inferior}."
msgstr "Retorna a lista de pacotes conhecidos por @var{inferior}."

msgid "{Procedure} lookup-inferior-packages inferior name [version]"
msgstr "{Procedimento} lookup-inferior-packages inferior nome [versão]"

msgid "Return the sorted list of inferior packages matching @var{name} in @var{inferior}, with highest version numbers first.  If @var{version} is true, return only packages with a version number prefixed by @var{version}."
msgstr "Retorna a lista ordenada de pacotes inferiores que correspondem a @var{nome} em @var{inferior}, com os números de versão mais altos primeiro. Se @var{versão} for true, retorna apenas pacotes com um número de versão prefixado por @var{versão}."

msgid "{Procedure} inferior-package? obj"
msgstr "{Procedimento} inferior-package? obj"

msgid "Return true if @var{obj} is an inferior package."
msgstr "Retorna verdadeiro se @var{obj} for um pacote inferior."

msgid "{Procedure} inferior-package-name package"
msgstr "{Procedimento} inferior-package-name pacote"

msgid "{Procedure} inferior-package-version package"
msgstr "{Procedimento} inferior-package-version pacote"

msgid "{Procedure} inferior-package-synopsis package"
msgstr "{Procedimento} inferior-package-synopsis pacote"

msgid "{Procedure} inferior-package-description package"
msgstr "{Procedimento} inferior-package-description pacote"

msgid "{Procedure} inferior-package-home-page package"
msgstr "{Procedimento} inferior-package-home-page pacote"

msgid "{Procedure} inferior-package-location package"
msgstr "{Procedimento} inferior-package-location pacote"

msgid "{Procedure} inferior-package-inputs package"
msgstr "{Procedimento} inferior-package-inputs pacote"

msgid "{Procedure} inferior-package-native-inputs package"
msgstr "{Procedimento} inferior-package-native-inputs pacote"

msgid "{Procedure} inferior-package-propagated-inputs package"
msgstr "{Procedimento} inferior-package-propagated-inputs pacote"

msgid "{Procedure} inferior-package-transitive-propagated-inputs package"
msgstr "{Procedimento} inferior-package-transitive-propagated-inputs pacote"

msgid "{Procedure} inferior-package-native-search-paths package"
msgstr "{Procedimento} inferior-package-native-search-paths pacote"

msgid "{Procedure} inferior-package-transitive-native-search-paths package"
msgstr "{Procedimento} inferior-package-transitive-native-search-paths pacote"

msgid "{Procedure} inferior-package-search-paths package"
msgstr "{Procedimento} inferior-package-search-paths pacote"

msgid "These procedures are the counterpart of package record accessors (@pxref{package Reference}).  Most of them work by querying the inferior @var{package} comes from, so the inferior must still be live when you call these procedures."
msgstr "Esses procedimentos são a contrapartida dos acessadores de registro de pacote (@pxref{package Reference}). A maioria deles funciona consultando o inferior de onde @var{pacote} vem, então o inferior ainda deve estar ativo quando você chamar esses procedimentos."

msgid "Inferior packages can be used transparently like any other package or file-like object in G-expressions (@pxref{G-Expressions}).  They are also transparently handled by the @code{packages->manifest} procedure, which is commonly used in manifests (@pxref{Invoking guix package, the @option{--manifest} option of @command{guix package}}).  Thus you can insert an inferior package pretty much anywhere you would insert a regular package: in manifests, in the @code{packages} field of your @code{operating-system} declaration, and so on."
msgstr "Pacotes inferiores podem ser usados transparentemente como qualquer outro pacote ou objeto tipo arquivo em expressões-G (@pxref{G-Expressions}). Eles também são manipulados transparentemente pelo procedimento @code{packages->manifest}, que é comumente usado em manifestos (@pxref{Invoking guix package, a opção @option{--manifest} de @command{guix package}}). Assim, você pode inserir um pacote inferior praticamente em qualquer lugar em que inseriria um pacote regular: em manifestos, no campo @code{packages} da sua declaração @code{operating-system} e assim por diante."

msgid "Invoking @command{guix describe}"
msgstr "Invocando @command{guix describe}"

msgid "guix describe"
msgstr "guix describe"

msgid "Often you may want to answer questions like: ``Which revision of Guix am I using?'' or ``Which channels am I using?'' This is useful information in many situations: if you want to @emph{replicate} an environment on a different machine or user account, if you want to report a bug or to determine what change in the channels you are using caused it, or if you want to record your system state for reproducibility purposes.  The @command{guix describe} command answers these questions."
msgstr "Frequentemente você pode querer responder perguntas como: ``Qual revisão do Guix estou usando?'' ou ``Quais canais estou usando?'' Essas são informações úteis em muitas situações: se você quiser @emph{replicar} um ambiente em uma máquina ou conta de usuário diferente, se quiser relatar um bug ou determinar qual alteração nos canais que você está usando o causou, ou se quiser registrar o estado do seu sistema para fins de reprodutibilidade. O comando @command{guix describe} responde a essas perguntas."

msgid "When run from a @command{guix pull}ed @command{guix}, @command{guix describe} displays the channel(s) that it was built from, including their repository URL and commit IDs (@pxref{Channels}):"
msgstr "Quando executado a partir de um @command{guix} obtido com @command{guix pull}, @command{guix describe} exibe o(s) canal(ais) dos quais foi criado, incluindo a URL do repositório e os IDs de confirmação (@pxref{Channels}):"

msgid ""
"$ guix describe\n"
"Generation 10\tSep 03 2018 17:32:44\t(current)\n"
"  guix e0fa68c\n"
"    repository URL: https://git.guix.gnu.org/guix.git\n"
"    branch: master\n"
"    commit: e0fa68c7718fffd33d81af415279d6ddb518f727\n"
msgstr ""
"$ guix describe\n"
"Geração 10\t03 set 2018 17:32:44\t(atual)\n"
"  guix e0fa68c\n"
"    URL do repositório: https://git.guix.gnu.org/guix.git\n"
"    ramo: master\n"
"    commit: e0fa68c7718fffd33d81af415279d6ddb518f727\n"

msgid "If you're familiar with the Git version control system, this is similar in spirit to @command{git describe}; the output is also similar to that of @command{guix pull --list-generations}, but limited to the current generation (@pxref{Invoking guix pull, the @option{--list-generations} option}).  Because the Git commit ID shown above unambiguously refers to a snapshot of Guix, this information is all it takes to describe the revision of Guix you're using, and also to replicate it."
msgstr "Se você estiver familiarizado com o sistema de controle de versão do Git, isso é similar em espírito a @command{git describe}; a saída também é similar à de @command{guix pull --list-generations}, mas limitada à geração atual (@pxref{Invoking guix pull, a opção @option{--list-generations}}). Como o ID de commit do Git mostrado acima se refere inequivocamente a um snapshot do Guix, essa informação é tudo o que é preciso para descrever a revisão do Guix que você está usando e também para replicá-la."

msgid "To make it easier to replicate Guix, @command{guix describe} can also be asked to return a list of channels instead of the human-readable description above:"
msgstr "Para facilitar a replicação do Guix, @command{guix describe} também pode ser solicitado a retornar uma lista de canais em vez da descrição legível acima:"

msgid ""
"$ guix describe -f channels\n"
"(list (channel\n"
"        (name 'guix)\n"
"        (url \"https://git.guix.gnu.org/guix.git\")\n"
"        (commit\n"
"          \"e0fa68c7718fffd33d81af415279d6ddb518f727\")\n"
"        (introduction\n"
"          (make-channel-introduction\n"
"            \"9edb3f66fd807b096b48283debdcddccfea34bad\"\n"
"            (openpgp-fingerprint\n"
"              \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\")))))\n"
msgstr ""
"$ guix describe -f channels\n"
"(list (channel\n"
"        (name 'guix)\n"
"        (url \"https://git.guix.gnu.org/guix.git\")\n"
"        (commit\n"
"          \"e0fa68c7718fffd33d81af415279d6ddb518f727\")\n"
"        (introduction\n"
"          (make-channel-introduction\n"
"            \"9edb3f66fd807b096b48283debdcddccfea34bad\"\n"
"            (openpgp-fingerprint\n"
"              \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\")))))\n"

msgid "You can save this to a file and feed it to @command{guix pull -C} on some other machine or at a later point in time, which will instantiate @emph{this exact Guix revision} (@pxref{Invoking guix pull, the @option{-C} option}).  From there on, since you're able to deploy the same revision of Guix, you can just as well @emph{replicate a complete software environment}.  We humbly think that this is @emph{awesome}, and we hope you'll like it too!"
msgstr "Você pode salvar isso em um arquivo e alimentá-lo com @command{guix pull -C} em alguma outra máquina ou em um momento posterior, o que instanciará @emph{esta revisão exata do Guix} (@pxref{Invoking guix pull, a opção @option{-C}}). A partir daí, já que você consegue implementar a mesma revisão do Guix, você pode muito bem @emph{replicar um ambiente de software completo}. Humildemente achamos isso @emph{incrível}, e esperamos que você goste também!"

msgid "The details of the options supported by @command{guix describe} are as follows:"
msgstr "Os detalhes das opções suportadas por @command{guix describe} são os seguintes:"

msgid "--format=@var{format}"
msgstr "--format=@var{formato}"

msgid "-f @var{format}"
msgstr "-f @var{formato}"

msgid "Produce output in the specified @var{format}, one of:"
msgstr "Produza saída no @var{formato} especificado, um dos seguintes:"

msgid "human"
msgstr "human"

msgid "produce human-readable output;"
msgstr "produzir resultados legíveis por humanos;"

msgid "channels"
msgstr "channels"

msgid "produce a list of channel specifications that can be passed to @command{guix pull -C} or installed as @file{~/.config/guix/channels.scm} (@pxref{Invoking guix pull});"
msgstr "produz uma lista de especificações de canal que podem ser passadas para @command{guix pull -C} ou instaladas como @file{~/.config/guix/channels.scm} (@pxref{Invoking guix pull});"

msgid "channels-sans-intro"
msgstr "channels-sans-intro"

msgid "like @code{channels}, but omit the @code{introduction} field; use it to produce a channel specification suitable for Guix version 1.1.0 or earlier---the @code{introduction} field has to do with channel authentication (@pxref{Channels, Channel Authentication}) and is not supported by these older versions;"
msgstr "como @code{channels}, mas omita o campo @code{introduction}; use-o para produzir uma especificação de canal adequada para a versão 1.1.0 do Guix ou anterior --- o campo @code{introduction} tem a ver com autenticação de canal (@pxref{Channels, Autenticação de canal}) e não é suportado por essas versões mais antigas;"

msgid "json"
msgstr "json"

msgid "JSON"
msgstr "JSON"

msgid "produce a list of channel specifications in JSON format;"
msgstr "produzir uma lista de especificações de canal no formato JSON;"

msgid "recutils"
msgstr "recutils"

msgid "produce a list of channel specifications in Recutils format."
msgstr "produzir uma lista de especificações de canais no formato Recutils."

msgid "--list-formats"
msgstr "--list-formats"

msgid "Display available formats for @option{--format} option."
msgstr "Exibir formatos disponíveis para a opção @option{--format}."

msgid "Display information about @var{profile}."
msgstr "Exibir informações sobre @var{perfil}."

msgid "Invoking @command{guix archive}"
msgstr "Invocando @command{guix archive}"

msgid "guix archive"
msgstr "guix archive"

msgid "archive"
msgstr "arquivo"

msgid "exporting files from the store"
msgstr "exportando arquivos do armazém"

msgid "importing files to the store"
msgstr "importando arquivos para o armazém"

msgid "The @command{guix archive} command allows users to @dfn{export} files from the store into a single archive, and to later @dfn{import} them on a machine that runs Guix.  In particular, it allows store files to be transferred from one machine to the store on another machine."
msgstr "O comando @command{guix archive} permite que os usuários @dfn{exportem} arquivos do armazém para um único arquivamento e depois @dfn{importem} eles em uma máquina que execute o Guix. Em particular, ele permite que os arquivos do armazém sejam transferidos de uma máquina para o store em outra máquina."

msgid "If you're looking for a way to produce archives in a format suitable for tools other than Guix, @pxref{Invoking guix pack}."
msgstr "Se você estiver procurando uma maneira de produzir arquivamentos em um formato adequado para outras ferramentas além do Guix, @pxref{Invoking guix pack}."

msgid "exporting store items"
msgstr "exportando itens do armazém"

msgid "To export store files as an archive to standard output, run:"
msgstr "Para exportar arquivos de armazém como um arquivamento para saída padrão, execute:"

msgid "guix archive --export @var{options} @var{specifications}...\n"
msgstr "guix archive --export @var{opções} @var{especificações}...\n"

msgid "@var{specifications} may be either store file names or package specifications, as for @command{guix package} (@pxref{Invoking guix package}).  For instance, the following command creates an archive containing the @code{gui} output of the @code{git} package and the main output of @code{emacs}:"
msgstr "@var{especificações} pode ser nomes de arquivos de armazém ou especificações de pacotes, como para @command{guix package} (@pxref{Invoking guix package}). Por exemplo, o comando a seguir cria um arquivo contendo a saída @code{gui} do pacote @code{git} e a saída principal de @code{emacs}:"

msgid "guix archive --export git:gui /gnu/store/...-emacs-24.3 > great.nar\n"
msgstr "guix archive --export git:gui /gnu/store/...-emacs-24.3 > great.nar\n"

msgid "If the specified packages are not built yet, @command{guix archive} automatically builds them.  The build process may be controlled with the common build options (@pxref{Common Build Options})."
msgstr "Se os pacotes especificados ainda não foram construídos, @command{guix archive} os constrói automaticamente. O processo de construção pode ser controlado com as opções comuns de construção (@pxref{Common Build Options})."

msgid "To transfer the @code{emacs} package to a machine connected over SSH, one would run:"
msgstr "Para transferir o pacote @code{emacs} para uma máquina conectada via SSH, execute:"

msgid "guix archive --export -r emacs | ssh the-machine guix archive --import\n"
msgstr "guix archive --export -r emacs | ssh a-máquina guix archive --import\n"

msgid "Similarly, a complete user profile may be transferred from one machine to another like this:"
msgstr "Da mesma forma, um perfil de usuário completo pode ser transferido de uma máquina para outra assim:"

msgid ""
"guix archive --export -r $(readlink -f ~/.guix-profile) | \\\n"
"  ssh the-machine guix archive --import\n"
msgstr ""
"guix archive --export -r $(readlink -f ~/.guix-profile) | \\\n"
"  ssh a-máquina guix archive --import\n"

msgid "However, note that, in both examples, all of @code{emacs} and the profile as well as all of their dependencies are transferred (due to @option{-r}), regardless of what is already available in the store on the target machine.  The @option{--missing} option can help figure out which items are missing from the target store.  The @command{guix copy} command simplifies and optimizes this whole process, so this is probably what you should use in this case (@pxref{Invoking guix copy})."
msgstr "No entanto, observe que, em ambos os exemplos, todos os @code{emacs} e o perfil, bem como todas as suas dependências são transferidos (devido a @option{-r}), independentemente do que já esteja disponível no armazém na máquina de destino. A opção @option{--missing} pode ajudar a descobrir quais itens estão faltando no armazém de destino. O comando @command{guix copy} simplifica e otimiza todo esse processo, então é provavelmente isso que você deve usar neste caso (@pxref{Invoking guix copy})."

msgid "nar, archive format"
msgstr "nar, formato de arquivamento"

msgid "normalized archive (nar)"
msgstr "arquivamento normalizado (nar)"

msgid "nar bundle, archive format"
msgstr "embalagem nar, formato de arquivamento"

msgid "Each store item is written in the @dfn{normalized archive} or @dfn{nar} format (described below), and the output of @command{guix archive --export} (and input of @command{guix archive --import}) is a @dfn{nar bundle}."
msgstr "Cada item do armazém é escrito no formato @dfn{arquivamento normalizado} ou @dfn{nar} (descrito abaixo), e a saída de @command{guix archive --export} (e entrada de @command{guix archive --import}) é uma @dfn{embalagem nar}."

msgid "The nar format is comparable in spirit to `tar', but with differences that make it more appropriate for our purposes.  First, rather than recording all Unix metadata for each file, the nar format only mentions the file type (regular, directory, or symbolic link); Unix permissions and owner/group are dismissed.  Second, the order in which directory entries are stored always follows the order of file names according to the C locale collation order.  This makes archive production fully deterministic."
msgstr "O formato nar é comparável em espírito ao `tar', mas com diferenças que o tornam mais apropriado para nossos propósitos. Primeiro, em vez de registrar todos os metadados Unix para cada arquivo, o formato nar menciona apenas o tipo de arquivo (regular, diretório ou ligação simbólica); permissões Unix e proprietário/grupo são descartados. Segundo, a ordem em que as entradas de diretório são armazenadas sempre segue a ordem dos nomes de arquivo de acordo com a ordem de agrupamento de localidade C. Isso torna a produção de arquivo totalmente determinística."

msgid "That nar bundle format is essentially the concatenation of zero or more nars along with metadata for each store item it contains: its file name, references, corresponding derivation, and a digital signature."
msgstr "O formato da embalagem nar é essencialmente a concatenação de zero ou mais nars junto com metadados para cada item de armazém que ele contém: seu nome de arquivo, referências, derivação correspondente e uma assinatura digital."

msgid "When exporting, the daemon digitally signs the contents of the archive, and that digital signature is appended.  When importing, the daemon verifies the signature and rejects the import in case of an invalid signature or if the signing key is not authorized."
msgstr "Ao exportar, o daemon assina digitalmente o conteúdo do arquivamento, e essa assinatura digital é anexada. Ao importar, o daemon verifica a assinatura e rejeita a importação em caso de uma assinatura inválida ou se a chave de assinatura não for autorizada."

msgid "The main options are:"
msgstr "As principais opções são:"

msgid "--export"
msgstr "--export"

msgid "Export the specified store files or packages (see below).  Write the resulting archive to the standard output."
msgstr "Exporte os arquivos de armazém ou pacotes especificados (veja abaixo). Grave o arquivo resultante na saída padrão."

msgid "Dependencies are @emph{not} included in the output, unless @option{--recursive} is passed."
msgstr "Dependências @emph{não} são incluídas na saída, a menos que @option{--recursive} seja passado."

msgid "-r"
msgstr "-r"

msgid "--recursive"
msgstr "--recursive"

msgid "When combined with @option{--export}, this instructs @command{guix archive} to include dependencies of the given items in the archive.  Thus, the resulting archive is self-contained: it contains the closure of the exported store items."
msgstr "Quando combinado com @option{--export}, isso instrui @command{guix archive} a incluir dependências dos itens fornecidos no arquivo. Assim, o arquivo resultante é autocontido: ele contém o fechamento dos itens exportados do armazém."

msgid "--import"
msgstr "--import"

msgid "Read an archive from the standard input, and import the files listed therein into the store.  Abort if the archive has an invalid digital signature, or if it is signed by a public key not among the authorized keys (see @option{--authorize} below)."
msgstr "Leia um arquivo da entrada padrão e importe os arquivos listados nele para o armazém. Aborte se o arquivo tiver uma assinatura digital inválida ou se for assinado por uma chave pública que não esteja entre as chaves autorizadas (veja @option{--authorize} abaixo)."

msgid "--missing"
msgstr "--missing"

msgid "Read a list of store file names from the standard input, one per line, and write on the standard output the subset of these files missing from the store."
msgstr "Leia uma lista de nomes de arquivos do armazém da entrada padrão, um por linha, e escreva na saída padrão o subconjunto desses arquivos que faltam no armazém."

msgid "--generate-key[=@var{parameters}]"
msgstr "--generate-key[=@var{parâmetros}]"

msgid "signing, archives"
msgstr "assinatura, arquivos"

msgid "Generate a new key pair for the daemon.  This is a prerequisite before archives can be exported with @option{--export}.  This operation is usually instantaneous but it can take time if the system's entropy pool needs to be refilled.  On Guix System, @code{guix-service-type} takes care of generating this key pair the first boot."
msgstr "Gere um novo par de chaves para o daemon. Este é um pré-requisito antes que os arquivos possam ser exportados com @option{--export}. Esta operação é geralmente instantânea, mas pode levar algum tempo se o pool de entropia do sistema precisar ser recarregado. No Guix System, @code{guix-service-type} cuida da geração deste par de chaves na primeira inicialização."

msgid "The generated key pair is typically stored under @file{/etc/guix}, in @file{signing-key.pub} (public key) and @file{signing-key.sec} (private key, which must be kept secret).  When @var{parameters} is omitted, an ECDSA key using the Ed25519 curve is generated, or, for Libgcrypt versions before 1.6.0, it is a 4096-bit RSA key.  Alternatively, @var{parameters} can specify @code{genkey} parameters suitable for Libgcrypt (@pxref{General public-key related Functions, @code{gcry_pk_genkey},, gcrypt, The Libgcrypt Reference Manual})."
msgstr "O par de chaves gerado é normalmente armazenado em @file{/etc/guix}, em @file{signing-key.pub} (chave pública) e @file{signing-key.sec} (chave privada, que deve ser mantida em segredo). Quando @var{parâmetros} é omitido, uma chave ECDSA usando a curva Ed25519 é gerada ou, para versões do Libgcrypt anteriores a 1.6.0, é uma chave RSA de 4096 bits. Como alternativa, @var{parâmetros} pode especificar parâmetros @code{genkey} adequados para Libgcrypt (@pxref{General public-key related Functions, @code{gcry_pk_genkey},, gcrypt, Manual de referência do Libgcrypt})."

msgid "--authorize"
msgstr "--authorize"

msgid "authorizing, archives"
msgstr "autorizando, arquivamentos"

msgid "Authorize imports signed by the public key passed on standard input.  The public key must be in ``s-expression advanced format''---i.e., the same format as the @file{signing-key.pub} file."
msgstr "Autorize importações assinadas pela chave pública passada na entrada padrão. A chave pública deve estar em ``s-expression advanced format''---i.e., o mesmo formato do arquivo @file{signing-key.pub}."

msgid "The list of authorized keys is kept in the human-editable file @file{/etc/guix/acl}.  The file contains @url{https://people.csail.mit.edu/rivest/Sexp.txt, ``advanced-format s-expressions''} and is structured as an access-control list in the @url{https://theworld.com/~cme/spki.txt, Simple Public-Key Infrastructure (SPKI)}."
msgstr "A lista de chaves autorizadas é mantida no arquivo editável por humanos @file{/etc/guix/acl}. O arquivo contém @url{https://people.csail.mit.edu/rivest/Sexp.txt, ``advanced-format s-expressions''} e é estruturado como uma lista de controle de acesso no @url{https://theworld.com/~cme/spki.txt, Simple Public-Key Infrastructure (SPKI)}."

msgid "--extract=@var{directory}"
msgstr "--extract=@var{diretório}"

msgid "-x @var{directory}"
msgstr "-x @var{diretório}"

msgid "Read a single-item archive as served by substitute servers (@pxref{Substitutes}) and extract it to @var{directory}.  This is a low-level operation needed in only very narrow use cases; see below."
msgstr "Leia um arquivo de item único conforme servido por servidores substitutos (@pxref{Substitutes}) e extraia-o para @var{diretório}. Esta é uma operação de baixo nível necessária apenas em casos de uso muito restritos; veja abaixo."

msgid "For example, the following command extracts the substitute for Emacs served by @code{@value{SUBSTITUTE-SERVER-1}} to @file{/tmp/emacs}:"
msgstr "Por exemplo, o comando a seguir extrai o substituto para o Emacs servido por @code{@value{SUBSTITUTE-SERVER-1}} para @file{/tmp/emacs}:"

msgid ""
"$ wget -O - \\\n"
"  https://@value{SUBSTITUTE-SERVER-1}/nar/gzip/@dots{}-emacs-24.5 \\\n"
"  | gunzip | guix archive -x /tmp/emacs\n"
msgstr ""
"$ wget -O - \\\n"
"  https://@value{SUBSTITUTE-SERVER-1}/nar/gzip/@dots{}-emacs-24.5 \\\n"
"  | gunzip | guix archive -x /tmp/emacs\n"

msgid "Single-item archives are different from multiple-item archives produced by @command{guix archive --export}; they contain a single store item, and they do @emph{not} embed a signature.  Thus this operation does @emph{no} signature verification and its output should be considered unsafe."
msgstr "Arquivamentos de item único são diferentes de arquivamentos de itens múltiplos produzidos por @command{guix archive --export}; eles contêm um único item de armazém e não @emph{incorporam} uma assinatura. Portanto, essa operação não faz @emph{nenhuma} verificação de assinatura e sua saída deve ser considerada insegura."

msgid "The primary purpose of this operation is to facilitate inspection of archive contents coming from possibly untrusted substitute servers (@pxref{Invoking guix challenge})."
msgstr "O objetivo principal desta operação é facilitar a inspeção de conteúdos de arquivamento provenientes de servidores substitutos possivelmente não confiáveis (@pxref{Invoking guix challenge})."

msgid "--list"
msgstr "--list"

msgid "-t"
msgstr "-t"

msgid "Read a single-item archive as served by substitute servers (@pxref{Substitutes}) and print the list of files it contains, as in this example:"
msgstr "Leia um arquivamento de item único servido por servidores substitutos (@pxref{Substitutes}) e exiba a lista de arquivos que ele contém, como neste exemplo:"

msgid ""
"$ wget -O - \\\n"
"  https://@value{SUBSTITUTE-SERVER-1}/nar/lzip/@dots{}-emacs-26.3 \\\n"
"  | lzip -d | guix archive -t\n"
msgstr ""
"$ wget -O - \\\n"
"  https://@value{SUBSTITUTE-SERVER-1}/nar/lzip/@dots{}-emacs-26.3 \\\n"
"  | lzip -d | guix archive -t\n"

msgid "@command{guix pull}, configuration file"
msgstr "@command{guix pull}, arquivo de configuração"

msgid "configuration of @command{guix pull}"
msgstr "configuração de @command{guix pull}"

msgid "Guix and its package collection are updated by running @command{guix pull}.  By default @command{guix pull} downloads and deploys Guix itself from the official GNU@tie{}Guix repository.  This can be customized by providing a file specifying the set of @dfn{channels} to pull from (@pxref{Invoking guix pull}).  A channel specifies the URL and branch of a Git repository to be deployed, and @command{guix pull} can be instructed to pull from one or more channels.  In other words, channels can be used to @emph{customize} and to @emph{extend} Guix, as we will see below.  Guix is able to take into account security concerns and deal with authenticated updates."
msgstr "Guix e sua coleção de pacotes são atualizados executando @command{guix pull}. Por padrão, @command{guix pull} baixa e implementa o próprio Guix do repositório oficial GNU@tie{}Guix. Isso pode ser personalizado fornecendo um arquivo especificando o conjunto de @dfn{canais} para extrair de (@pxref{Invoking guix pull}). Um canal especifica a URL e a ramificação de um repositório Git a ser implantado, e @command{guix pull} pode ser instruído a extrair de um ou mais canais. Em outras palavras, os canais podem ser usados para @emph{personalizar} e @emph{estender} o Guix, como veremos abaixo. O Guix é capaz de levar em conta preocupações de segurança e lidar com atualizações autenticadas."

msgid "extending the package collection (channels)"
msgstr "estendendo a coleção de pacotes (canais)"

msgid "variant packages (channels)"
msgstr "pacotes variantes (canais)"

msgid "You can specify @emph{additional channels} to pull from.  To use a channel, write @code{~/.config/guix/channels.scm} to instruct @command{guix pull} to pull from it @emph{in addition} to the default Guix channel(s):"
msgstr "Você pode especificar @emph{canais adicionais} para puxar. Para usar um canal, escreva @code{~/.config/guix/channels.scm} para instruir @command{guix pull} para puxar dele @emph{além} do(s) canal(ais) Guix padrão:"

msgid "%default-channels"
msgstr "%default-channels"

msgid ""
";; Add variant packages to those Guix provides.\n"
"(cons (channel\n"
"        (name 'variant-packages)\n"
"        (url \"https://example.org/variant-packages.git\"))\n"
"      %default-channels)\n"
msgstr ""
";; Adicione pacotes variantes aos fornecidos pelo Guix.\n"
"(cons (channel\n"
"        (name 'variant-packages)\n"
"        (url \"https://example.org/variant-packages.git\"))\n"
"      %default-channels)\n"

msgid "Note that the snippet above is (as always!)@: Scheme code; we use @code{cons} to add a channel the list of channels that the variable @code{%default-channels} is bound to (@pxref{Pairs, @code{cons} and lists,, guile, GNU Guile Reference Manual}).  With this file in place, @command{guix pull} builds not only Guix but also the package modules from your own repository.  The result in @file{~/.config/guix/current} is the union of Guix with your own package modules:"
msgstr "Note que o snippet acima é (como sempre!)@: código do Scheme; usamos @code{cons} para adicionar um canal à lista de canais aos quais a variável @code{%default-channels} está vinculada (@pxref{Pairs, @code{cons} and lists,, guile, GNU Guile Reference Manual}). Com esse arquivo no lugar, @command{guix pull} compila não apenas o Guix, mas também os módulos do pacote do seu próprio repositório. O resultado em @file{~/.config/guix/current} é a união do Guix com seus próprios módulos do pacote:"

msgid ""
"$ guix describe\n"
"Generation 19\tAug 27 2018 16:20:48\n"
"  guix d894ab8\n"
"    repository URL: https://git.guix.gnu.org/guix.git\n"
"    branch: master\n"
"    commit: d894ab8e9bfabcefa6c49d9ba2e834dd5a73a300\n"
"  variant-packages dd3df5e\n"
"    repository URL: https://example.org/variant-packages.git\n"
"    branch: master\n"
"    commit: dd3df5e2c8818760a8fc0bd699e55d3b69fef2bb\n"
msgstr ""
"$ guix describe\n"
"Geração 19\t27 ago 2018 16:20:48\n"
"  guix d894ab8\n"
"    URL do repositório: https://git.guix.gnu.org/guix.git\n"
"    ramo: master\n"
"    commit: d894ab8e9bfabcefa6c49d9ba2e834dd5a73a300\n"
"  variant-packages dd3df5e\n"
"    URL do repositório: https://example.org/variant-packages.git\n"
"    ramo: master\n"
"    commit: dd3df5e2c8818760a8fc0bd699e55d3b69fef2bb\n"

msgid "The output of @command{guix describe} above shows that we're now running Generation@tie{}19 and that it includes both Guix and packages from the @code{variant-packages} channel (@pxref{Invoking guix describe})."
msgstr "A saída do @command{guix describe} acima mostra que agora estamos executando o geração@tie{}19 e que ele inclui o Guix e os pacotes do canal @code{variant-packages} (@pxref{Invoking guix describe})."

msgid "The channel called @code{guix} specifies where Guix itself---its command-line tools as well as its package collection---should be downloaded.  For instance, suppose you want to update from another copy of the Guix repository at @code{example.org}, and specifically the @code{super-hacks} branch, you can write in @code{~/.config/guix/channels.scm} this specification:"
msgstr "O canal chamado @code{guix} especifica onde o próprio Guix---suas ferramentas de linha de comando, bem como sua coleção de pacotes---deve ser baixado. Por exemplo, suponha que você queira atualizar de outra cópia do repositório Guix em @code{example.org}, e especificamente o branch @code{super-hacks}, você pode escrever em @code{~/.config/guix/channels.scm} esta especificação:"

msgid ""
";; Tell 'guix pull' to use another repo.\n"
"(list (channel\n"
"        (name 'guix)\n"
"        (url \"https://example.org/another-guix.git\")\n"
"        (branch \"super-hacks\")))\n"
msgstr ""
";; Diga ao 'guix pull' para usar outro repositório.\n"
"(list (channel\n"
"        (name 'guix)\n"
"        (url \"https://example.org/another-guix.git\")\n"
"        (branch \"super-hacks\")))\n"

msgid "From there on, @command{guix pull} will fetch code from the @code{super-hacks} branch of the repository at @code{example.org}.  The authentication concern is addressed below (@pxref{Channel Authentication})."
msgstr "A partir daí, @command{guix pull} buscará o código do branch @code{super-hacks} do repositório em @code{example.org}. A preocupação com a autenticação é abordada abaixo (@pxref{Channel Authentication})."

msgid "Note that you can specify a local directory on the @code{url} field above if the channel that you intend to use resides on a local file system.  However, in this case @command{guix} checks said directory for ownership before any further processing.  This means that if the user is not the directory owner, but wants to use it as their default, they will then need to set it as a safe directory in their global git configuration file.  Otherwise, @command{guix} will refuse to even read it.  Supposing your system-wide local directory is at @code{/src/guix.git}, you would then create a git configuration file at @code{~/.gitconfig} with the following contents:"
msgstr "Note que você pode especificar um diretório local no campo @code{url} acima se o canal que você pretende usar residir em um sistema de arquivos local. No entanto, neste caso, @command{guix} verifica o diretório em busca de propriedade antes de qualquer processamento posterior. Isso significa que se o usuário não for o proprietário do diretório, mas quiser usá-lo como padrão, ele precisará defini-lo como um diretório seguro em seu arquivo de configuração global do git. Caso contrário, @command{guix} se recusará até mesmo a lê-lo. Supondo que seu diretório local de todo o sistema esteja em @code{/src/guix.git}, você criaria um arquivo de configuração do git em @code{~/.gitconfig} com o seguinte conteúdo:"

msgid ""
"[safe]\n"
"        directory = /src/guix.git\n"
msgstr ""
"[safe]\n"
"        directory = /src/guix.git\n"

msgid "This also applies to the root user unless when called with @command{sudo} by the directory owner."
msgstr "Isso também se aplica ao usuário root, a menos que seja chamado com @command{sudo} pelo proprietário do diretório."

msgid "The @command{guix describe} command shows precisely which commits were used to build the instance of Guix we're using (@pxref{Invoking guix describe}).  We can replicate this instance on another machine or at a different point in time by providing a channel specification ``pinned'' to these commits that looks like this:"
msgstr "O comando @command{guix describe} mostra precisamente quais commits foram usados para construir a instância do Guix que estamos usando (@pxref{Invoking guix describe}). Podemos replicar essa instância em outra máquina ou em um ponto diferente no tempo fornecendo uma especificação de canal ``fixada'' a esses commits que se parece com isso:"

msgid ""
";; Deploy specific commits of my channels of interest.\n"
"(list (channel\n"
"       (name 'guix)\n"
"       (url \"https://git.guix.gnu.org/guix.git\")\n"
"       (commit \"6298c3ffd9654d3231a6f25390b056483e8f407c\"))\n"
"      (channel\n"
"       (name 'variant-packages)\n"
"       (url \"https://example.org/variant-packages.git\")\n"
"       (commit \"dd3df5e2c8818760a8fc0bd699e55d3b69fef2bb\")))\n"
msgstr ""
";; Implantar commits específicos dos meus canais de interesse.\n"
"(list (channel\n"
"       (name 'guix)\n"
"       (url \"https://git.guix.gnu.org/guix.git\")\n"
"       (commit \"6298c3ffd9654d3231a6f25390b056483e8f407c\"))\n"
"      (channel\n"
"       (name 'variant-packages)\n"
"       (url \"https://example.org/variant-packages.git\")\n"
"       (commit \"dd3df5e2c8818760a8fc0bd699e55d3b69fef2bb\")))\n"

msgid "To obtain this pinned channel specification, the easiest way is to run @command{guix describe} and to save its output in the @code{channels} format in a file, like so:"
msgstr "Para obter essa especificação de canal fixado, a maneira mais fácil é executar @command{guix describe} e salvar sua saída no formato @code{channels} em um arquivo, assim:"

msgid "guix describe -f channels > channels.scm\n"
msgstr "guix describe -f channels > canais.scm\n"

msgid "The resulting @file{channels.scm} file can be passed to the @option{-C} option of @command{guix pull} (@pxref{Invoking guix pull}) or @command{guix time-machine} (@pxref{Invoking guix time-machine}), as in this example:"
msgstr "O arquivo @file{channels.scm} resultante pode ser passado para a opção @option{-C} de @command{guix pull} (@pxref{Invoking guix pull}) ou @command{guix time-machine} (@pxref{Invoking guix time-machine}), como neste exemplo:"

msgid "guix time-machine -C channels.scm -- shell python -- python3\n"
msgstr "guix time-machine -C channels.scm -- shell python -- python3\n"

msgid "Given the @file{channels.scm} file, the command above will always fetch the @emph{exact same Guix instance}, then use that instance to run the exact same Python (@pxref{Invoking guix shell}).  On any machine, at any time, it ends up running the exact same binaries, bit for bit."
msgstr "Dado o arquivo @file{channels.scm}, o comando acima sempre buscará a @emph{exatamente a mesma instância Guix}, então usará essa instância para executar exatamente o mesmo Python (@pxref{Invoking guix shell}). Em qualquer máquina, a qualquer momento, ele acaba executando exatamente os mesmos binários, bit por bit."

msgid "lock files"
msgstr "arquivo de bloqueio"

msgid "Pinned channels address a problem similar to ``lock files'' as implemented by some deployment tools---they let you pin and reproduce a set of packages.  In the case of Guix though, you are effectively pinning the entire package set as defined at the given channel commits; in fact, you are pinning all of Guix, including its core modules and command-line tools.  You're also getting strong guarantees that you are, indeed, obtaining the exact same software."
msgstr "Os canais fixados abordam um problema semelhante a ``arquivos de bloqueio'' conforme implementado por algumas ferramentas de implantação --- eles permitem que você fixe e reproduza um conjunto de pacotes. No caso do Guix, no entanto, você está efetivamente fixando o conjunto de pacotes inteiro conforme definido nos commits de canal fornecidos; na verdade, você está fixando todo o Guix, incluindo seus módulos principais e ferramentas de linha de comando. Você também está obtendo fortes garantias de que está, de fato, obtendo exatamente o mesmo software."

msgid "This gives you super powers, allowing you to track the provenance of binary artifacts with very fine grain, and to reproduce software environments at will---some sort of ``meta reproducibility'' capabilities, if you will.  @xref{Inferiors}, for another way to take advantage of these super powers."
msgstr "Isso lhe dá superpoderes, permitindo que você rastreie a procedência de artefatos binários com granularidade muito fina e reproduza ambientes de software à vontade --- algum tipo de capacidade de ``meta reprodutibilidade'', se preferir. @xref{Inferiors}, para outra maneira de aproveitar esses superpoderes."

msgid "channels, for the default Guix"
msgstr "canais, para o Guix padrão"

msgid "If you're running Guix System or building system images with it, maybe you will want to customize the system-wide @command{guix} it provides---specifically, @file{/run/current-system/profile/bin/guix}.  For example, you might want to provide additional channels or to pin its revision."
msgstr "Se você estiver executando o Guix System ou construindo imagens de sistema com ele, talvez você queira personalizar o @command{guix} de todo o sistema que ele fornece---especificamente, @file{/run/current-system/profile/bin/guix}. Por exemplo, você pode querer fornecer canais adicionais ou fixar sua revisão."

msgid "This can be done using the @code{guix-for-channels} procedure, which returns a package for the given channels, and using it as part of your operating system configuration, as in this example:"
msgstr "Isso pode ser feito usando o procedimento @code{guix-for-channels}, que retorna um pacote para os canais fornecidos e o usa como parte da configuração do seu sistema operacional, como neste exemplo:"

msgid ""
"(use-modules (gnu packages package-management)\n"
"             (guix channels))\n"
"\n"
msgstr ""
"(use-modules (gnu packages package-management)\n"
"             (guix channels))\n"
"\n"

msgid ""
"(define my-channels\n"
"  ;; Channels that should be available to\n"
"  ;; /run/current-system/profile/bin/guix.\n"
"  (append\n"
"   (list (channel\n"
"          (name 'guix-science)\n"
"          (url \"https://codeberg.org/guix-science/guix-science\")\n"
"          (branch \"master\")))\n"
"   %default-channels))\n"
"\n"
msgstr ""
"(define my-channels\n"
"  ;; Canais que devem estar disponíveis para\n"
"  ;; /run/current-system/profile/bin/guix.\n"
"  (append\n"
"   (list (channel\n"
"          (name 'guix-science)\n"
"          (url \"https://codeberg.org/guix-science/guix-science\")\n"
"          (branch \"master\")))\n"
"   %default-channels))\n"
"\n"

msgid "The resulting operating system will have both the @code{guix} and the @code{guix-science} channels visible by default.  The @code{channels} field of @code{guix-configuration} above further ensures that @file{/etc/guix/channels.scm}, which is used by @command{guix pull}, specifies the same set of channels (@pxref{guix-configuration-channels, @code{channels} field of @code{guix-configuration}})."
msgstr "O sistema operacional resultante terá os canais @code{guix} e @code{guix-science} visíveis por padrão. O campo @code{channels} de @code{guix-configuration} acima garante ainda mais que @file{/etc/guix/channels.scm}, que é usado por @command{guix pull}, especifica o mesmo conjunto de canais (@pxref{guix-configuration-channels, campo @code{channels} de @code{guix-configuration}})."

msgid "The @code{(gnu packages package-management)} module exports the @code{guix-for-channels} procedure, described below."
msgstr "O módulo @code{(gnu packages package-management)} exporta o procedimento @code{guix-for-channels}, descrito abaixo."

msgid "{Procedure} guix-for-channels @var{channels}"
msgstr "{Procedimento} guix-for-channels @var{canais}"

msgid "Return a package corresponding to @var{channels}."
msgstr "Retorna um pacote correspondente a @var{canais}."

msgid "The result is a ``regular'' package, which can be used in @code{guix-configuration} as shown above or in any other place that expects a package."
msgstr "O resultado é um pacote ``regular'', que pode ser usado em @code{guix-configuration} como mostrado acima ou em qualquer outro lugar que espere um pacote."

msgid "channel-authentication"
msgstr "channel-authentication"

msgid "The @command{guix pull} and @command{guix time-machine} commands @dfn{authenticate} the code retrieved from channels: they make sure each commit that is fetched is signed by an authorized developer.  The goal is to protect from unauthorized modifications to the channel that would lead users to run malicious code."
msgstr "Os comandos @command{guix pull} e @command{guix time-machine} @dfn{autenticam} o código recuperado dos canais: eles garantem que cada commit que é buscado seja assinado por um desenvolvedor autorizado. O objetivo é proteger contra modificações não autorizadas no canal que levariam os usuários a executar código malicioso."

msgid "As a user, you must provide a @dfn{channel introduction} in your channels file so that Guix knows how to authenticate its first commit.  A channel specification, including its introduction, looks something along these lines:"
msgstr "Como usuário, você deve fornecer uma @dfn{introdução de canal} no seu arquivo de canais para que o Guix saiba como autenticar seu primeiro commit. Uma especificação de canal, incluindo sua introdução, parece algo como estas linhas:"

msgid ""
"(channel\n"
"  (name 'some-channel)\n"
"  (url \"https://example.org/some-channel.git\")\n"
"  (introduction\n"
"   (make-channel-introduction\n"
"    \"6f0d8cc0d88abb59c324b2990bfee2876016bb86\"\n"
"    (openpgp-fingerprint\n"
"     \"CABB A931 C0FF EEC6 900D  0CFB 090B 1199 3D9A EBB5\"))))\n"
msgstr ""
"(channel\n"
"  (name 'algum-canal)\n"
"  (url \"https://example.org/algum-canal.git\")\n"
"  (introduction\n"
"   (make-channel-introduction\n"
"    \"6f0d8cc0d88abb59c324b2990bfee2876016bb86\"\n"
"    (openpgp-fingerprint\n"
"     \"CABB A931 C0FF EEC6 900D  0CFB 090B 1199 3D9A EBB5\"))))\n"

msgid "The specification above shows the name and URL of the channel.  The call to @code{make-channel-introduction} above specifies that authentication of this channel starts at commit @code{6f0d8cc@dots{}}, which is signed by the OpenPGP key with fingerprint @code{CABB A931@dots{}}."
msgstr "A especificação acima mostra o nome e a URL do canal. A chamada para @code{make-channel-introduction} acima especifica que a autenticação deste canal começa no commit @code{6f0d8cc@dots{}}, que é assinado pela chave OpenPGP com impressão digital @code{CABB A931@dots{}}."

msgid "For the main channel, called @code{guix}, you automatically get that information from your Guix installation.  For other channels, include the channel introduction provided by the channel authors in your @file{channels.scm} file.  Make sure you retrieve the channel introduction from a trusted source since that is the root of your trust."
msgstr "Para o canal principal, chamado @code{guix}, você obtém automaticamente essas informações da sua instalação Guix. Para outros canais, inclua a introdução do canal fornecida pelos autores do canal no seu arquivo @file{channels.scm}. Certifique-se de recuperar a introdução do canal de uma fonte confiável, pois essa é a raiz da sua confiança."

msgid "If you're curious about the authentication mechanics, read on!"
msgstr "Se você está curioso sobre a mecânica de autenticação, continue lendo!"

msgid "When running @command{guix pull}, Guix will first compile the definitions of every available package.  This is an expensive operation for which substitutes (@pxref{Substitutes}) may be available.  The following snippet in @file{channels.scm} will ensure that @command{guix pull} uses the latest commit with available substitutes for the package definitions: this is done by querying the continuous integration server at @url{https://ci.guix.gnu.org}."
msgstr "Ao executar @command{guix pull}, o Guix primeiro compilará as definições de cada pacote disponível. Esta é uma operação cara para a qual substitutos (@pxref{Substitutes}) podem estar disponíveis. O seguinte snippet em @file{channels.scm} garantirá que o @command{guix pull} use o commit mais recente com substitutos disponíveis para as definições de pacote: isso é feito consultando o servidor de integração contínua em @url{https://ci.guix.gnu.org}."

msgid ""
"(use-modules (guix ci))\n"
"\n"
msgstr ""
"(use-modules (guix ci))\n"
"\n"

msgid ""
"(list (channel-with-substitutes-available\n"
"       %default-guix-channel\n"
"       \"https://ci.guix.gnu.org\"))\n"
msgstr ""
"(list (channel-with-substitutes-available\n"
"       %default-guix-channel\n"
"       \"https://ci.guix.gnu.org\"))\n"

msgid "Note that this does not mean that all the packages that you will install after running @command{guix pull} will have available substitutes.  It only ensures that @command{guix pull} will not try to compile package definitions.  This is particularly useful when using machines with limited resources."
msgstr "Note que isso não significa que todos os pacotes que você instalará após executar @command{guix pull} terão substitutos disponíveis. Isso apenas garante que @command{guix pull} não tentará compilar definições de pacotes. Isso é particularmente útil ao usar máquinas com recursos limitados."

msgid "personal packages (channels)"
msgstr "pacotes pessoais (canais)"

msgid "channels, for personal packages"
msgstr "canais, para pacotes pessoais"

msgid "Let's say you have a bunch of custom package variants or personal packages that you think would make little sense to contribute to the Guix project, but would like to have these packages transparently available to you at the command line.  By creating a @dfn{channel}, you can use and publish such a package collection.  This involves the following steps:"
msgstr "Digamos que você tenha um monte de variantes de pacotes personalizados ou pacotes pessoais que você acha que faria pouco sentido contribuir para o projeto Guix, mas gostaria de ter esses pacotes disponíveis de forma transparente para você na linha de comando. Ao criar um @dfn{canal}, você pode usar e publicar tal coleção de pacotes. Isso envolve as seguintes etapas:"

msgid "A channel lives in a Git repository so the first step, when creating a channel, is to create its repository:"
msgstr "Um canal fica em um repositório Git, então o primeiro passo, ao criar um canal, é criar seu repositório:"

msgid ""
"mkdir my-channel\n"
"cd my-channel\n"
"git init\n"
msgstr ""
"mkdir meu-canal\n"
"cd meu-canal\n"
"git init\n"

msgid "The next step is to create files containing package modules (@pxref{Package Modules}), each of which will contain one or more package definitions (@pxref{Defining Packages}).  A channel can provide things other than packages, such as build systems or services; we're using packages as it's the most common use case."
msgstr "O próximo passo é criar arquivos contendo módulos de pacote (@pxref{Package Modules}), cada um dos quais conterá uma ou mais definições de pacote (@pxref{Defining Packages}). Um canal pode fornecer coisas além de pacotes, como sistemas de compilação ou serviços; estamos usando pacotes, pois é o caso de uso mais comum."

msgid "For example, Alice might want to provide a module called @code{(alice packages greetings)} that will provide her favorite ``hello world'' implementations.  To do that Alice will create a directory corresponding to that module name."
msgstr "Por exemplo, Alice pode querer fornecer um módulo chamado @code{(alice packages greetings)} que fornecerá suas implementações favoritas de ``hello world''. Para fazer isso, Alice criará um diretório correspondente ao nome desse módulo."

msgid ""
"mkdir -p alice/packages\n"
"$EDITOR alice/packages/greetings.scm\n"
"git add alice/packages/greetings.scm\n"
msgstr ""
"mkdir -p alice/packages\n"
"$EDITOR alice/packages/greetings.scm\n"
"git add alice/packages/greetings.scm\n"

msgid "You can name your package modules however you like; the main constraint to keep in mind is to avoid name clashes with other package collections, which is why our hypothetical Alice wisely chose the @code{(alice packages @dots{})} name space."
msgstr "Você pode nomear seus módulos de pacote como quiser; a principal restrição a ter em mente é evitar conflitos de nomes com outras coleções de pacotes, e é por isso que nossa hipotética Alice sabiamente escolheu o namespace @code{(alice packages @dots{})}."

msgid "Note that you can also place modules in a sub-directory of the repository; @pxref{Package Modules in a Sub-directory}, for more info on that."
msgstr "Observe que você também pode colocar módulos em um subdiretório do repositório; @pxref{Package Modules in a Sub-directory}, para mais informações sobre isso."

msgid "With this first module in place, the next step is to test the packages it provides.  This can be done with @command{guix build}, which needs to be told to look for modules in the Git checkout.  For example, assuming @code{(alice packages greetings)} provides a package called @code{hi-from-alice}, Alice will run this command from the Git checkout:"
msgstr "Com este primeiro módulo em funcionamento, o próximo passo é testar os pacotes que ele fornece. Isso pode ser feito com @command{guix build}, que precisa ser informado para procurar módulos no checkout do Git. Por exemplo, supondo que @code{(alice packages greetings)} forneça um pacote chamado @code{hi-from-alice}, Alice executará este comando do checkout do Git:"

msgid "guix build -L. hi-from-alice\n"
msgstr "guix build -L. hi-from-alice\n"

msgid "... where @code{-L.} adds the current directory to Guile's load path (@pxref{Load Paths,,, guile, GNU Guile Reference Manual})."
msgstr "... onde @code{-L.} adiciona o diretório atual ao caminho de carregamento do Guile (@pxref{Load Paths,,, guile, Manual de referência do GNU Guile})."

msgid "It might take Alice a few iterations to obtain satisfying package definitions.  Eventually Alice will commit this file:"
msgstr "Pode levar algumas iterações para Alice obter definições de pacote satisfatórias. Eventualmente, Alice fará commit deste arquivo:"

msgid "git commit\n"
msgstr "git commit\n"

msgid "As a channel author, consider bundling authentication material with your channel so that users can authenticate it.  @xref{Channel Authentication}, and @ref{Specifying Channel Authorizations}, for info on how to do it."
msgstr "Como autor de um canal, considere agrupar material de autenticação com seu canal para que os usuários possam autenticá-lo. @xref{Channel Authentication} e @ref{Specifying Channel Authorizations} para obter informações sobre como fazer isso."

msgid "To use Alice's channel, anyone can now add it to their channel file (@pxref{Specifying Additional Channels}) and run @command{guix pull} (@pxref{Invoking guix pull}):"
msgstr "Para usar o canal de Alice, qualquer pessoa pode adicioná-lo ao seu arquivo de canal (@pxref{Specifying Additional Channels}) e executar @command{guix pull} (@pxref{Invoking guix pull}):"

msgid ""
"$EDITOR ~/.config/guix/channels.scm\n"
"guix pull\n"
msgstr ""
"$EDITOR ~/.config/guix/channels.scm\n"
"guix pull\n"

msgid "Guix will now behave as if the root directory of that channel's Git repository had been permanently added to the Guile load path.  In this example, @code{(alice packages greetings)} will automatically be found by the @command{guix} command."
msgstr "Guix agora se comportará como se o diretório raiz do repositório Git daquele canal tivesse sido adicionado permanentemente ao caminho de carregamento do Guile. Neste exemplo, @code{(alice packages greetings)} será encontrado automaticamente pelo comando @command{guix}."

msgid "Voilà!"
msgstr "Voilà!"

msgid "Before you publish your channel, we would like to share a few words of caution:"
msgstr "Antes de publicar seu canal, gostaríamos de compartilhar algumas palavras de cautela:"

msgid "Before publishing a channel, please consider contributing your package definitions to Guix proper (@pxref{Contributing}).  Guix as a project is open to free software of all sorts, and packages in Guix proper are readily available to all Guix users and benefit from the project's quality assurance process."
msgstr "Antes de publicar um canal, considere contribuir com suas definições de pacote para o Guix propriamente dito (@pxref{Contributing}). O Guix como um projeto é aberto a software livre de todos os tipos, e os pacotes no Guix propriamente dito estão prontamente disponíveis para todos os usuários do Guix e se beneficiam do processo de garantia de qualidade do projeto."

msgid "Corollary: if you're using an external channel and that channel breaks, please @emph{report the issue to the channel authors}, not to the Guix project."
msgstr "Corolário: se você estiver usando um canal externo e esse canal quebrar, @emph{reporte o problema aos autores do canal}, não ao projeto Guix."

msgid "You've been warned! Having said this, we believe external channels are a practical way to exert your freedom to augment Guix' package collection and to share your improvements, which are basic tenets of @uref{https://www.gnu.org/philosophy/free-sw.html, free software}.  Please email us at @email{guix-devel@@gnu.org} if you'd like to discuss this."
msgstr "Você foi avisado! Dito isso, acreditamos que canais externos são uma maneira prática de exercer sua liberdade para aumentar a coleção de pacotes do Guix e compartilhar suas melhorias, que são princípios básicos do @uref{https://www.gnu.org/philosophy/free-sw.html, software livre}. Por favor, envie um e-mail para @email{guix-devel@@gnu.org} se você quiser discutir isso."

msgid "subdirectory, channels"
msgstr "subdiretório, canais"

msgid "As a channel author, you may want to keep your channel modules in a sub-directory.  If your modules are in the sub-directory @file{guix}, you must add a meta-data file @file{.guix-channel} that contains:"
msgstr "Como autor de canal, você pode querer manter seus módulos de canal em um subdiretório. Se seus módulos estiverem no subdiretório @file{guix}, você deve adicionar um arquivo de metadados @file{.guix-channel} que contenha:"

msgid "The modules must be @b{underneath} the specified directory, as the @code{directory} changes Guile's @code{load-path}.  For example, if @file{.guix-channel} has @code{(directory \"base\")}, then a module defined as @code{(define-module (gnu packages fun))} must be located at @code{base/gnu/packages/fun.scm}."
msgstr "Os módulos devem estar @b{abaixo} do diretório especificado, pois o diretório @code{directory} altera o @code{load-path} do Guile. Por exemplo, se @file{.guix-channel} tiver @code{(directory \"base\")}, então um módulo definido como @code{(define-module (gnu packages fun))} deve estar localizado em @code{base/gnu/packages/fun.scm}."

msgid "Doing this allows for only parts of a repository to be used as a channel, as Guix expects valid Guile modules when pulling.  For instance, @command{guix deploy} machine configuration files are not valid Guile modules, and treating them as such would make @command{guix pull} fail."
msgstr "Fazer isso permite que apenas partes de um repositório sejam usadas como um canal, pois o Guix espera módulos Guile válidos ao puxar. Por exemplo, os arquivos de configuração de máquina @command{guix deploy} não são módulos Guile válidos, e tratá-los como tal faria com que @command{guix pull} falhasse."

msgid "dependencies, channels"
msgstr "dependências, canais"

msgid "meta-data, channels"
msgstr "metadados, canais"

msgid "Channel authors may decide to augment a package collection provided by other channels.  They can declare their channel to be dependent on other channels in a meta-data file @file{.guix-channel}, which is to be placed in the root of the channel repository."
msgstr "Os autores de canais podem decidir aumentar uma coleção de pacotes fornecida por outros canais. Eles podem declarar que seu canal é dependente de outros canais em um arquivo de metadados @file{.guix-channel}, que deve ser colocado na raiz do repositório do canal."

msgid "The meta-data file should contain a simple S-expression like this:"
msgstr "O arquivo de metadados deve conter uma expressão S simples como esta:"

msgid ""
"(channel\n"
" (version 0)\n"
" (dependencies\n"
"  (channel\n"
"   (name some-collection)\n"
"   (url \"https://example.org/first-collection.git\")\n"
"\n"
msgstr ""
"(channel\n"
" (version 0)\n"
" (dependencies\n"
"  (channel\n"
"   (name algum-coleção)\n"
"   (url \"https://example.org/first-collection.git\")\n"
"\n"

msgid "In the above example this channel is declared to depend on two other channels, which will both be fetched automatically.  The modules provided by the channel will be compiled in an environment where the modules of all these declared channels are available."
msgstr "No exemplo acima, este canal é declarado para depender de dois outros canais, que serão buscados automaticamente. Os módulos fornecidos pelo canal serão compilados em um ambiente onde os módulos de todos esses canais declarados estão disponíveis."

msgid "For the sake of reliability and maintainability, you should avoid dependencies on channels that you don't control, and you should aim to keep the number of dependencies to a minimum."
msgstr "Por uma questão de confiabilidade e manutenibilidade, você deve evitar dependências em canais que você não controla e deve tentar manter o número de dependências no mínimo."

msgid "channel authorizations"
msgstr "autorizações de canal"

msgid "channel-authorizations"
msgstr "channel-authorizations"

msgid "As we saw above, Guix ensures the source code it pulls from channels comes from authorized developers.  As a channel author, you need to specify the list of authorized developers in the @file{.guix-authorizations} file in the channel's Git repository.  The authentication rule is simple: each commit must be signed by a key listed in the @file{.guix-authorizations} file of its parent commit(s)@footnote{Git commits form a @dfn{directed acyclic graph} (DAG).  Each commit can have zero or more parents; ``regular'' commits have one parent and merge commits have two parent commits.  Read @uref{https://eagain.net/articles/git-for-computer-scientists/, @i{Git for Computer Scientists}} for a great overview.} The @file{.guix-authorizations} file looks like this:"
msgstr "Como vimos acima, o Guix garante que o código-fonte que ele extrai dos canais vem de desenvolvedores autorizados. Como autor de um canal, você precisa especificar a lista de desenvolvedores autorizados no arquivo @file{.guix-authorizations} no repositório Git do canal. A regra de autenticação é simples: cada commit deve ser assinado por uma chave listada no arquivo @file{.guix-authorizations} de seu(s) commit(s) pai(s)@footnote{Os commits do Git formam um @dfn{gráfico acíclico direcionado} (DAG). Cada commit pode ter zero ou mais pais; os commits ``regulares'' têm um pai e os commits de mesclagem têm dois commits pais. Leia @uref{https://eagain.net/articles/git-for-computer-scientists/, @i{Git para cientistas da computação}} para uma ótima visão geral.} O arquivo @file{.guix-authorizations} se parece com isso:"

msgid ""
";; Example '.guix-authorizations' file.\n"
"\n"
msgstr ""
";; Exemplo de arquivo '.guix-authorizations'.\n"
"\n"

msgid "Each fingerprint is followed by optional key/value pairs, as in the example above.  Currently these key/value pairs are ignored."
msgstr "Cada impressão digital é seguida por pares chave/valor opcionais, como no exemplo acima. Atualmente, esses pares chave/valor são ignorados."

msgid "This authentication rule creates a chicken-and-egg issue: how do we authenticate the first commit? Related to that: how do we deal with channels whose repository history contains unsigned commits and lack @file{.guix-authorizations}? And how do we fork existing channels?"
msgstr "Esta regra de autenticação cria um problema do tipo \"ovo e galinha\": como autenticamos o primeiro commit? Relacionado a isso: como lidamos com canais cujo histórico de repositório contém commits não assinados e não tem @file{.guix-authorizations}? E como bifurcamos canais existentes?"

msgid "channel introduction"
msgstr "introdução do canal"

msgid "Channel introductions answer these questions by describing the first commit of a channel that should be authenticated.  The first time a channel is fetched with @command{guix pull} or @command{guix time-machine}, the command looks up the introductory commit and verifies that it is signed by the specified OpenPGP key.  From then on, it authenticates commits according to the rule above.  Authentication fails if the target commit is neither a descendant nor an ancestor of the introductory commit."
msgstr "As introduções de canal respondem a essas perguntas descrevendo o primeiro commit de um canal que deve ser autenticado. Na primeira vez que um canal é buscado com @command{guix pull} ou @command{guix time-machine}, o comando procura o commit introdutório e verifica se ele está assinado pela chave OpenPGP especificada. A partir daí, ele autentica os commits de acordo com a regra acima. A autenticação falha se o commit de destino não for descendente nem ancestral do commit introdutório."

msgid "Additionally, your channel must provide all the OpenPGP keys that were ever mentioned in @file{.guix-authorizations}, stored as @file{.key} files, which can be either binary or ``ASCII-armored''.  By default, those @file{.key} files are searched for in the branch named @code{keyring} but you can specify a different branch name in @code{.guix-channel} like so:"
msgstr "Além disso, seu canal deve fornecer todas as chaves OpenPGP que já foram mencionadas em @file{.guix-authorizations}, armazenadas como arquivos @file{.key}, que podem ser binários ou ``ASCII-armored''. Por padrão, esses arquivos @file{.key} são pesquisados no branch chamado @code{keyring}, mas você pode especificar um nome de branch diferente em @code{.guix-channel} assim:"

msgid "To summarize, as the author of a channel, there are three things you have to do to allow users to authenticate your code:"
msgstr "Para resumir, como autor de um canal, há três coisas que você precisa fazer para permitir que os usuários autentiquem seu código:"

msgid "Export the OpenPGP keys of past and present committers with @command{gpg --export} and store them in @file{.key} files, by default in a branch named @code{keyring} (we recommend making it an @dfn{orphan branch})."
msgstr "Exporte as chaves OpenPGP de contribuidores anteriores e atuais com @command{gpg --export} e armazene-as em arquivos @file{.key}, por padrão em uma ramificação chamada @code{keyring} (recomendamos torná-la uma @dfn{ramificação órfã})."

msgid "Introduce an initial @file{.guix-authorizations} in the channel's repository.  Do that in a signed commit (@pxref{Commit Access}, for information on how to sign Git commits)."
msgstr "Introduza um @file{.guix-authorizations} inicial no repositório do canal. Faça isso em um commit assinado (@pxref{Commit Access}, para obter informações sobre como assinar commits do Git)."

msgid "Advertise the channel introduction, for instance on your channel's web page.  The channel introduction, as we saw above, is the commit/key pair---i.e., the commit that introduced @file{.guix-authorizations}, and the fingerprint of the OpenPGP used to sign it."
msgstr "Anuncie a introdução do canal, por exemplo, na página web do seu canal. A introdução do canal, como vimos acima, é o par commit/chave---i.e., o commit que introduziu @file{.guix-authorizations}, e a impressão digital do OpenPGP usada para assiná-lo."

msgid "Before pushing to your public Git repository, you can run @command{guix git authenticate} to verify that you did sign all the commits you are about to push with an authorized key:"
msgstr "Antes de enviar para seu repositório Git público, você pode executar @command{guix git authenticate} para verificar se você assinou todos os commits que está prestes a enviar com uma chave autorizada:"

msgid "where @var{commit} and @var{signer} are your channel introduction.  @xref{Invoking guix git authenticate}, for details."
msgstr "onde @var{commit} e @var{signer} são a introdução do seu canal. @xref{Invoking guix git authenticate}, para detalhes."

msgid "Publishing a signed channel requires discipline: any mistake, such as an unsigned commit or a commit signed by an unauthorized key, will prevent users from pulling from your channel---well, that's the whole point of authentication! Pay attention to merges in particular: merge commits are considered authentic if and only if they are signed by a key present in the @file{.guix-authorizations} file of @emph{both} branches."
msgstr "Publicar um canal assinado requer disciplina: qualquer erro, como um commit não assinado ou um commit assinado por uma chave não autorizada, impedirá que usuários puxem do seu canal --- bem, esse é o ponto principal da autenticação! Preste atenção às mesclagens em particular: commits de mesclagem são considerados autênticos se e somente se forem assinados por uma chave presente no arquivo @file{.guix-authorizations} de @emph{ambos} os ramos."

msgid "primary URL, channels"
msgstr "URL principal, canais"

msgid "Channel authors can indicate the primary URL of their channel's Git repository in the @file{.guix-channel} file, like so:"
msgstr "Os autores do canal podem indicar a URL principal do repositório Git do canal no arquivo @file{.guix-channel}, assim:"

msgid ""
"(channel\n"
"  (version 0)\n"
"  (url \"https://example.org/guix.git\"))\n"
msgstr ""
"(channel\n"
"  (version 0)\n"
"  (url \"https://example.org/guix.git\"))\n"

msgid "This allows @command{guix pull} to determine whether it is pulling code from a mirror of the channel; when that is the case, it warns the user that the mirror might be stale and displays the primary URL@.  That way, users cannot be tricked into fetching code from a stale mirror that does not receive security updates."
msgstr "Isso permite que @command{guix pull} determine se está puxando código de um espelho do canal; quando esse for o caso, ele avisa o usuário que o espelho pode estar obsoleto e exibe a URL primária. Dessa forma, os usuários não podem ser enganados para buscar código de um espelho obsoleto que não recebe atualizações de segurança."

msgid "This feature only makes sense for authenticated repositories, such as the official @code{guix} channel, for which @command{guix pull} ensures the code it fetches is authentic."
msgstr "Esse recurso só faz sentido para repositórios autenticados, como o canal oficial @code{guix}, para o qual @command{guix pull} garante que o código que ele recupera é autêntico."

msgid "news, for channels"
msgstr "notícias, para canais"

msgid "Channel authors may occasionally want to communicate to their users information about important changes in the channel.  You'd send them all an email, but that's not convenient."
msgstr "Os autores do canal podem ocasionalmente querer comunicar aos seus usuários informações sobre mudanças importantes no canal. Você enviaria um e-mail para todos eles, mas isso não é conveniente."

msgid "Instead, channels can provide a @dfn{news file}; when the channel users run @command{guix pull}, that news file is automatically read and @command{guix pull --news} can display the announcements that correspond to the new commits that have been pulled, if any."
msgstr "Em vez disso, os canais podem fornecer um @dfn{arquivo de notícias}; quando os usuários do canal executam @command{guix pull}, esse arquivo de notícias é lido automaticamente e @command{guix pull --news} pode exibir os anúncios que correspondem aos novos commits que foram extraídos, se houver."

msgid "To do that, channel authors must first declare the name of the news file in their @file{.guix-channel} file:"
msgstr "Para fazer isso, os autores do canal devem primeiro declarar o nome do arquivo de notícias em seu arquivo @file{.guix-channel}:"

msgid ""
"(channel\n"
"  (version 0)\n"
"  (news-file \"etc/news.txt\"))\n"
msgstr ""
"(channel\n"
"  (version 0)\n"
"  (news-file \"etc/news.txt\"))\n"

msgid "The news file itself, @file{etc/news.txt} in this example, must look something like this:"
msgstr "O arquivo de notícias em si, @file{etc/news.txt} neste exemplo, deve ser parecido com isto:"

msgid ""
"(channel-news\n"
"  (version 0)\n"
"  (entry (tag \"the-bug-fix\")\n"
"         (title (en \"Fixed terrible bug\")\n"
"                (fr \"Oh la la\"))\n"
"         (body (en \"@@emph@{Good news@}!  It's fixed!\")\n"
"               (eo \"Certe ĝi pli bone funkcias nun!\")))\n"
"  (entry (commit \"bdcabe815cd28144a2d2b4bc3c5057b051fa9906\")\n"
"         (title (en \"Added a great package\")\n"
"                (ca \"Què vol dir guix?\"))\n"
"         (body (en \"Don't miss the @@code@{hello@} package!\"))))\n"
msgstr ""
"(channel-news\n"
"  (version 0)\n"
"  (entry (tag \"the-bug-fix\")\n"
"         (title (en \"Fixed terrible bug\")\n"
"                (fr \"Oh la la\"))\n"
"         (body (en \"@@emph@{Good news@}!  It's fixed!\")\n"
"               (eo \"Certe ĝi pli bone funkcias nun!\")))\n"
"  (entry (commit \"bdcabe815cd28144a2d2b4bc3c5057b051fa9906\")\n"
"         (title (en \"Added a great package\")\n"
"                (ca \"Què vol dir guix?\"))\n"
"         (body (en \"Don't miss the @@code@{hello@} package!\"))))\n"

msgid "While the news file is using the Scheme syntax, avoid naming it with a @file{.scm} extension or else it will get picked up when building the channel and yield an error since it is not a valid module.  Alternatively, you can move the channel module to a subdirectory and store the news file in another directory."
msgstr "Enquanto o arquivo de notícias estiver usando a sintaxe Scheme, evite nomeá-lo com uma extensão @file{.scm} ou então ele será pego ao construir o canal e gerará um erro, pois não é um módulo válido. Como alternativa, você pode mover o módulo do canal para um subdiretório e armazenar o arquivo de notícias em outro diretório."

msgid "The file consists of a list of @dfn{news entries}.  Each entry is associated with a commit or tag: it describes changes made in this commit, possibly in preceding commits as well.  Users see entries only the first time they obtain the commit the entry refers to."
msgstr "O arquivo consiste em uma lista de @dfn{entradas de notícias}. Cada entrada é associada a um commit ou tag: ela descreve as alterações feitas neste commit, possivelmente em commits anteriores também. Os usuários veem as entradas somente na primeira vez que obtêm o commit ao qual a entrada se refere."

msgid "The @code{title} field should be a one-line summary while @code{body} can be arbitrarily long, and both can contain Texinfo markup (@pxref{Overview,,, texinfo, GNU Texinfo}).  Both the title and body are a list of language tag/message tuples, which allows @command{guix pull} to display news in the language that corresponds to the user's locale."
msgstr "O campo @code{title} deve ser um resumo de uma linha, enquanto @code{body} pode ser arbitrariamente longo, e ambos podem conter marcação Texinfo (@pxref{Overview,,, texinfo, GNU Texinfo}). Tanto o título quanto o corpo são uma lista de tuplas de tag/mensagem de idioma, o que permite que @command{guix pull} exiba notícias no idioma que corresponde à localidade do usuário."

msgid "If you want to translate news using a gettext-based workflow, you can extract translatable strings with @command{xgettext} (@pxref{xgettext Invocation,,, gettext, GNU Gettext Utilities}).  For example, assuming you write news entries in English first, the command below creates a PO file containing the strings to translate:"
msgstr "Se você quiser traduzir notícias usando um fluxo de trabalho baseado em gettext, você pode extrair strings traduzíveis com @command{xgettext} (@pxref{xgettext Invocation,,, gettext, GNU Gettext Utilities}). Por exemplo, supondo que você escreva entradas de notícias em inglês primeiro, o comando abaixo cria um arquivo PO contendo as strings a serem traduzidas:"

msgid "xgettext -o news.po -l scheme -ken etc/news.txt\n"
msgstr "xgettext -o news.po -l scheme -ken etc/news.txt\n"

msgid "To sum up, yes, you could use your channel as a blog.  But beware, this is @emph{not quite} what your users might expect."
msgstr "Para resumir, sim, você pode usar seu canal como um blog. Mas cuidado, isso é @emph{não é bem} o que seus usuários podem esperar."

msgid "software development"
msgstr "desenvolvimento de software"

msgid "If you are a software developer, Guix provides tools that you should find helpful---independently of the language you're developing in.  This is what this chapter is about."
msgstr "Se você é um desenvolvedor de software, o Guix fornece ferramentas que você achará úteis, independentemente da linguagem em que estiver desenvolvendo. É sobre isso que este capítulo trata."

msgid "The @command{guix shell} command provides a convenient way to set up one-off software environments, be it for development purposes or to run a command without installing it in your profile.  The @command{guix pack} command allows you to create @dfn{application bundles} that can be easily distributed to users who do not run Guix."
msgstr "O comando @command{guix shell} fornece uma maneira conveniente de configurar ambientes de software únicos, seja para fins de desenvolvimento ou para executar um comando sem instalá-lo em seu perfil. O comando @command{guix pack} permite que você crie @dfn{embalagens de aplicativos} que podem ser facilmente distribuídas para usuários que não executam o Guix."

msgid "Invoking @command{guix shell}"
msgstr "Invocando @command{guix shell}"

msgid "reproducible build environments"
msgstr "ambientes de construção reproduzíveis"

msgid "development environments"
msgstr "ambientes de desenvolvimento"

msgid "guix environment"
msgstr "guix environment"

msgid "guix shell"
msgstr "guix shell"

msgid "environment, package build environment"
msgstr "ambiente, ambiente de construção de pacotes"

msgid "The purpose of @command{guix shell} is to make it easy to create one-off software environments, without changing one's profile.  It is typically used to create development environments; it is also a convenient way to run applications without ``polluting'' your profile."
msgstr "O propósito do @command{guix shell} é facilitar a criação de ambientes de software únicos, sem alterar o perfil. Ele é normalmente usado para criar ambientes de desenvolvimento; também é uma maneira conveniente de executar aplicativos sem ``poluir'' seu perfil."

msgid "The @command{guix shell} command was recently introduced to supersede @command{guix environment} (@pxref{Invoking guix environment}).  If you are familiar with @command{guix environment}, you will notice that it is similar but also---we hope!---more convenient."
msgstr "O comando @command{guix shell} foi introduzido recentemente para substituir @command{guix environment} (@pxref{Invoking guix environment}). Se você estiver familiarizado com @command{guix environment}, notará que ele é semelhante, mas também---esperamos!---mais conveniente."

msgid "guix shell [@var{options}] [@var{package}@dots{}]\n"
msgstr "guix shell [@var{opções}] [@var{pacote}@dots{}]\n"

msgid "Sometimes an interactive shell session is not desired.  An arbitrary command may be invoked by placing the @code{--} token to separate the command from the rest of the arguments."
msgstr "Às vezes, uma sessão de shell interativa não é desejada. Um comando arbitrário pode ser invocado colocando o token @code{--} para separar o comando do resto dos argumentos."

msgid "The following example creates an environment containing Python and NumPy, building or downloading any missing package, and runs the @command{python3} command in that environment:"
msgstr "O exemplo a seguir cria um ambiente contendo Python e NumPy, compilando ou baixando qualquer pacote ausente e executa o comando @command{python3} nesse ambiente:"

msgid "guix shell python python-numpy -- python3\n"
msgstr "guix shell python python-numpy -- python3\n"

msgid "Note that it is necessary to include the main @code{python} package in this command even if it is already installed into your environment.  This is so that the shell environment knows to set @env{PYTHONPATH} and other related variables.  The shell environment cannot check the previously installed environment, because then it would be non-deterministic.  This is true for most libraries: their corresponding language package should be included in the shell invocation."
msgstr "Note que é necessário incluir o pacote principal @code{python} neste comando, mesmo que ele já esteja instalado em seu ambiente. Isso é para que o ambiente shell saiba definir @env{PYTHONPATH} e outras variáveis relacionadas. O ambiente shell não pode verificar o ambiente instalado anteriormente, porque então seria não determinístico. Isso é verdade para a maioria das bibliotecas: seu pacote de linguagem correspondente deve ser incluído na invocação do shell."

msgid "shebang, for @command{guix shell}"
msgstr "shebang, para @command{guix shell}"

msgid "@command{guix shell} can be also be used as a script interpreter, also known as @dfn{shebang}.  Here is an example self-contained Python script making use of this feature:"
msgstr "@command{guix shell} também pode ser usado como um interpretador de script, também conhecido como @dfn{shebang}. Aqui está um exemplo de script Python autocontido fazendo uso desse recurso:"

msgid "You may pass any @command{guix shell} option, but there's one caveat: the Linux kernel has a limit of 127 bytes on shebang length."
msgstr "Você pode passar qualquer opção @command{guix shell}, mas há uma ressalva: o kernel Linux tem um limite de 127 bytes no comprimento do shebang."

msgid "Development environments can be created as in the example below, which spawns an interactive shell containing all the dependencies and environment variables needed to work on Inkscape:"
msgstr "Ambientes de desenvolvimento podem ser criados como no exemplo abaixo, que gera um shell interativo contendo todas as dependências e variáveis de ambiente necessárias para trabalhar no Inkscape:"

msgid "guix shell --development inkscape\n"
msgstr "guix shell --development inkscape\n"

msgid "Exiting the shell places the user back in the original environment before @command{guix shell} was invoked.  The next garbage collection (@pxref{Invoking guix gc}) may clean up packages that were installed in the environment and that are no longer used outside of it."
msgstr "Sair do shell coloca o usuário de volta no ambiente original antes de @command{guix shell} ser invocado. A próxima coleta de lixo (@pxref{Invoking guix gc}) pode limpar pacotes que foram instalados no ambiente e que não são mais usados fora dele."

msgid "As an added convenience, @command{guix shell} will try to do what you mean when it is invoked interactively without any other arguments as in:"
msgstr "Como uma conveniência adicional, @command{guix shell} tentará fazer o que você quer dizer quando for invocado interativamente sem nenhum outro argumento, como em:"

msgid "guix shell\n"
msgstr "guix shell\n"

msgid "If it finds a @file{manifest.scm} in the current working directory or any of its parents, it uses this manifest as though it was given via @code{--manifest}.  Likewise, if it finds a @file{guix.scm} in the same directories, it uses it to build a development profile as though both @code{--development} and @code{--file} were present.  In either case, the file will only be loaded if the directory it resides in is listed in @file{~/.config/guix/shell-authorized-directories}.  This provides an easy way to define, share, and enter development environments."
msgstr "Se encontrar um @file{manifest.scm} no diretório de trabalho atual ou em qualquer um dos seus pais, ele usa esse manifesto como se tivesse sido fornecido via @code{--manifest}. Da mesma forma, se encontrar um @file{guix.scm} nos mesmos diretórios, ele o usa para construir um perfil de desenvolvimento como se @code{--development} e @code{--file} estivessem presentes. Em ambos os casos, o arquivo só será carregado se o diretório em que ele reside estiver listado em @file{~/.config/guix/shell-authorized-directories}. Isso fornece uma maneira fácil de definir, compartilhar e entrar em ambientes de desenvolvimento."

msgid "By default, the shell session or command runs in an @emph{augmented} environment, where the new packages are added to search path environment variables such as @code{PATH}.  You can, instead, choose to create an @emph{isolated} environment containing nothing but the packages you asked for.  Passing the @option{--pure} option clears environment variable definitions found in the parent environment@footnote{Be sure to use the @option{--check} option the first time you use @command{guix shell} interactively to make sure the shell does not undo the effect of @option{--pure}.}; passing @option{--container} goes one step further by spawning a @dfn{container} isolated from the rest of the system:"
msgstr "Por padrão, a sessão ou comando do shell é executado em um ambiente @emph{aumentado}, onde os novos pacotes são adicionados às variáveis de ambiente do caminho de pesquisa, como @code{PATH}. Em vez disso, você pode escolher criar um ambiente @emph{isolado} contendo apenas os pacotes solicitados. Passar a opção @option{--pure} limpa as definições de variáveis de ambiente encontradas no ambiente pai@footnote{Certifique-se de usar a opção @option{--check} na primeira vez que usar @command{guix shell} interativamente para garantir que o shell não desfaça o efeito de @option{--pure}.}; passar @option{--container} vai um passo além ao gerar um @dfn{contêiner} isolado do resto do sistema:"

msgid "guix shell --container emacs gcc-toolchain\n"
msgstr "guix shell --container emacs gcc-toolchain\n"

msgid "The command above spawns an interactive shell in a container where nothing but @code{emacs}, @code{gcc-toolchain}, and their dependencies is available.  The container lacks network access and shares no files other than the current working directory with the surrounding environment.  This is useful to prevent access to system-wide resources such as @file{/usr/bin} on foreign distros."
msgstr "O comando acima gera um shell interativo em um contêiner onde nada além de @code{emacs}, @code{gcc-toolchain} e suas dependências estão disponíveis. O contêiner não tem acesso à rede e não compartilha nenhum arquivo além do diretório de trabalho atual com o ambiente ao redor. Isso é útil para evitar acesso a recursos de todo o sistema, como @file{/usr/bin} em distros estrangeiras."

msgid "This @option{--container} option can also prove useful if you wish to run a security-sensitive application, such as a web browser, in an isolated environment.  For example, the command below launches Ungoogled-Chromium in an isolated environment, which:"
msgstr "Esta opção @option{--container} também pode ser útil se você deseja executar um aplicativo sensível à segurança, como um navegador da web, em um ambiente isolado. Por exemplo, o comando abaixo inicia o Ungoogled-Chromium em um ambiente isolado, que:"

msgid "shares network access with the host"
msgstr "compartilha o acesso à rede com o host"

msgid "inherits host's environment variables @code{DISPLAY} and @code{XAUTHORITY}"
msgstr "herda as variáveis de ambiente do host @code{DISPLAY} e @code{XAUTHORITY}"

msgid "has access to host's authentication records from the @code{XAUTHORITY}"
msgstr "tem acesso aos registros de autenticação do host do @code{XAUTHORITY}"

msgid "file"
msgstr "file"

msgid "has no information about host's current directory"
msgstr "não tem informações sobre o diretório atual do host"

msgid ""
"guix shell --container --network --no-cwd ungoogled-chromium \\\n"
"  --preserve='^XAUTHORITY$' --expose=\"$@{XAUTHORITY@}\" \\\n"
"  --preserve='^DISPLAY$' -- chromium\n"
msgstr ""
"guix shell --container --network --no-cwd ungoogled-chromium \\\n"
"  --preserve='^XAUTHORITY$' --expose=\"$@{XAUTHORITY@}\" \\\n"
"  --preserve='^DISPLAY$' -- chromium\n"

msgid "GUIX_ENVIRONMENT"
msgstr "GUIX_ENVIRONMENT"

msgid "@command{guix shell} defines the @env{GUIX_ENVIRONMENT} variable in the shell it spawns; its value is the file name of the profile of this environment.  This allows users to, say, define a specific prompt for development environments in their @file{.bashrc} (@pxref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}):"
msgstr "@command{guix shell} define a variável @env{GUIX_ENVIRONMENT} no shell que ele gera; seu valor é o nome do arquivo do perfil deste ambiente. Isso permite que os usuários, digamos, definam um prompt específico para ambientes de desenvolvimento em seu @file{.bashrc} (@pxref{Bash Startup Files,,, bash, Manual de referência do GNU Bash}):"

msgid ""
"if [ -n \"$GUIX_ENVIRONMENT\" ]\n"
"then\n"
"    export PS1=\"\\u@@\\h \\w [dev]\\$ \"\n"
"fi\n"
msgstr ""
"if [ -n \"$GUIX_ENVIRONMENT\" ]\n"
"then\n"
"    export PS1=\"\\u@@\\h \\w [dev]\\$ \"\n"
"fi\n"

msgid "...@: or to browse the profile:"
msgstr "...@: ou para navegar pelo perfil:"

msgid "$ ls \"$GUIX_ENVIRONMENT/bin\"\n"
msgstr "$ ls \"$GUIX_ENVIRONMENT/bin\"\n"

msgid "The available options are summarized below."
msgstr "As opções disponíveis estão resumidas abaixo."

msgid "--check"
msgstr "--check"

msgid "Set up the environment and check whether the shell would clobber environment variables.  It's a good idea to use this option the first time you run @command{guix shell} for an interactive session to make sure your setup is correct."
msgstr "Configure o ambiente e verifique se o shell sobrecarregaria as variáveis de ambiente. É uma boa ideia usar esta opção na primeira vez que você executar @command{guix shell} para uma sessão interativa para garantir que sua configuração esteja correta."

msgid "For example, if the shell modifies the @env{PATH} environment variable, report it since you would get a different environment than what you asked for."
msgstr "Por exemplo, se o shell modificar a variável de ambiente @env{PATH}, informe isso, pois você obterá um ambiente diferente do que solicitou."

msgid "Such problems usually indicate that the shell startup files are unexpectedly modifying those environment variables.  For example, if you are using Bash, make sure that environment variables are set or modified in @file{~/.bash_profile} and @emph{not} in @file{~/.bashrc}---the former is sourced only by log-in shells.  @xref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}, for details on Bash start-up files."
msgstr "Tais problemas geralmente indicam que os arquivos de inicialização do shell estão modificando inesperadamente essas variáveis de ambiente. Por exemplo, se você estiver usando Bash, certifique-se de que as variáveis de ambiente estejam definidas ou modificadas em @file{~/.bash_profile} e @emph{não} em @file{~/.bashrc}---o primeiro é originado apenas por shells de login. @xref{Bash Startup Files,,, bash, Manual de referência do GNU Bash}, para detalhes sobre os arquivos de inicialização do Bash."

msgid "shell-development-option"
msgstr "shell-development-option"

msgid "--development"
msgstr "--development"

msgid "Cause @command{guix shell} to include in the environment the dependencies of the following package rather than the package itself.  This can be combined with other packages.  For instance, the command below starts an interactive shell containing the build-time dependencies of GNU@tie{}Guile, plus Autoconf, Automake, and Libtool:"
msgstr "Faça com que @command{guix shell} inclua no ambiente as dependências do pacote a seguir em vez do pacote em si. Isso pode ser combinado com outros pacotes. Por exemplo, o comando abaixo inicia um shell interativo contendo as dependências de tempo de compilação do GNU@tie{}Guile, além do Autoconf, Automake e Libtool:"

msgid "guix shell -D guile autoconf automake libtool\n"
msgstr "guix shell -D guile autoconf automake libtool\n"

msgid "--expression=@var{expr}"
msgstr "--expression=@var{expr}"

msgid "-e @var{expr}"
msgstr "-e @var{expr}"

msgid "Create an environment for the package or list of packages that @var{expr} evaluates to."
msgstr "Crie um ambiente para o pacote ou lista de pacotes que @var{expr} avalia."

msgid "For example, running:"
msgstr "Por exemplo, executando:"

msgid "guix shell -D -e '(@@ (gnu packages maths) petsc-openmpi)'\n"
msgstr "guix shell -D -e '(@@ (gnu packages maths) petsc-openmpi)'\n"

msgid "starts a shell with the environment for this specific variant of the PETSc package."
msgstr "inicia um shell com o ambiente para esta variante específica do pacote PETSc."

msgid "Running:"
msgstr "Rodando:"

msgid "guix shell -e '(@@ (gnu) %base-packages)'\n"
msgstr "guix shell -e '(@@ (gnu) %base-packages)'\n"

msgid "starts a shell with all the base system packages available."
msgstr "inicia um shell com todos os pacotes do sistema base disponíveis."

msgid "The above commands only use the default output of the given packages.  To select other outputs, two element tuples can be specified:"
msgstr "Os comandos acima usam apenas a saída padrão dos pacotes fornecidos. Para selecionar outras saídas, duas tuplas de elementos podem ser especificadas:"

msgid "guix shell -e '(list (@@ (gnu packages bash) bash) \"include\")'\n"
msgstr "guix shell -e '(list (@@ (gnu packages bash) bash) \"include\")'\n"

msgid "@xref{package-development-manifest, @code{package->development-manifest}}, for information on how to write a manifest for the development environment of a package."
msgstr "@xref{package-development-manifest, @code{package->development-manifest}}, para obter informações sobre como escrever um manifesto para o ambiente de desenvolvimento de um pacote."

msgid "--file=@var{file}"
msgstr "--file=@var{arquivo}"

msgid "Create an environment containing the package or list of packages that the code within @var{file} evaluates to."
msgstr "Crie um ambiente contendo o pacote ou lista de pacotes que o código dentro de @var{arquivo} avalia."

msgid "@verbatiminclude environment-gdb.scm\n"
msgstr "@verbatiminclude environment-gdb.scm\n"

msgid "With the file above, you can enter a development environment for GDB by running:"
msgstr "Com o arquivo acima, você pode entrar em um ambiente de desenvolvimento para o GDB executando:"

msgid "guix shell -D -f gdb-devel.scm\n"
msgstr "guix shell -D -f gdb-devel.scm\n"

msgid "shell-manifest"
msgstr "shell-manifest"

msgid "Create an environment for the packages contained in the manifest object returned by the Scheme code in @var{file}.  This option can be repeated several times, in which case the manifests are concatenated."
msgstr "Crie um ambiente para os pacotes contidos no objeto manifest retornado pelo código Scheme em @var{arquivo}. Esta opção pode ser repetida várias vezes, nesse caso os manifestos são concatenados."

msgid "This is similar to the same-named option in @command{guix package} (@pxref{profile-manifest, @option{--manifest}}) and uses the same manifest files."
msgstr "Isso é semelhante à opção de mesmo nome em @command{guix package} (@pxref{profile-manifest, @option{--manifest}}) e usa os mesmos arquivos de manifesto."

msgid "@xref{Writing Manifests}, for information on how to write a manifest.  See @option{--export-manifest} below on how to obtain a first manifest."
msgstr "@xref{Writing Manifests}, para informações sobre como escrever um manifesto. Veja @option{--export-manifest} abaixo sobre como obter um primeiro manifesto."

msgid "shell-export-manifest"
msgstr "shell-export-manifest"

msgid "Write to standard output a manifest suitable for @option{--manifest} corresponding to given command-line options."
msgstr "Grave na saída padrão um manifesto adequado para @option{--manifest} correspondente às opções de linha de comando fornecidas."

msgid "This is a way to ``convert'' command-line arguments into a manifest.  For example, imagine you are tired of typing long lines and would like to get a manifest equivalent to this command line:"
msgstr "Esta é uma maneira de ``converter'' argumentos de linha de comando em um manifesto. Por exemplo, imagine que você está cansado de digitar linhas longas e gostaria de obter um manifesto equivalente a esta linha de comando:"

msgid "guix shell -D guile git emacs emacs-geiser emacs-geiser-guile\n"
msgstr "guix shell -D guile git emacs emacs-geiser emacs-geiser-guile\n"

msgid "Just add @option{--export-manifest} to the command line above:"
msgstr "Basta adicionar @option{--export-manifest} à linha de comando acima:"

msgid ""
"guix shell --export-manifest \\\n"
"  -D guile git emacs emacs-geiser emacs-geiser-guile\n"
msgstr ""
"guix shell --export-manifest \\\n"
"  -D guile git emacs emacs-geiser emacs-geiser-guile\n"

msgid ""
"(concatenate-manifests\n"
"  (list (specifications->manifest\n"
"          (list \"git\"\n"
"                \"emacs\"\n"
"                \"emacs-geiser\"\n"
"                \"emacs-geiser-guile\"))\n"
"        (package->development-manifest\n"
"          (specification->package \"guile\"))))\n"
msgstr ""
"(concatenate-manifests\n"
"  (list (specifications->manifest\n"
"          (list \"git\"\n"
"                \"emacs\"\n"
"                \"emacs-geiser\"\n"
"                \"emacs-geiser-guile\"))\n"
"        (package->development-manifest\n"
"          (specification->package \"guile\"))))\n"

msgid "You can store it into a file, say @file{manifest.scm}, and from there pass it to @command{guix shell} or indeed pretty much any @command{guix} command:"
msgstr "Você pode armazená-lo em um arquivo, digamos @file{manifest.scm}, e de lá passá-lo para @command{guix shell} ou praticamente qualquer comando @command{guix}:"

msgid "guix shell -m manifest.scm\n"
msgstr "guix shell -m manifest.scm\n"

msgid "Voilà, you've converted a long command line into a manifest! That conversion process honors package transformation options (@pxref{Package Transformation Options}) so it should be lossless."
msgstr "Voilà, você converteu uma longa linha de comando em um manifesto! Esse processo de conversão honra opções de transformação de pacote (@pxref{Package Transformation Options}), então deve ser sem perdas."

msgid "Create an environment containing the packages installed in @var{profile}.  Use @command{guix package} (@pxref{Invoking guix package}) to create and manage profiles."
msgstr "Crie um ambiente contendo os pacotes instalados em @var{perfil}. Use @command{guix package} (@pxref{Invoking guix package}) para criar e gerenciar perfis."

msgid "--pure"
msgstr "--pure"

msgid "Unset existing environment variables when building the new environment, except those specified with @option{--preserve} (see below).  This has the effect of creating an environment in which search paths only contain package inputs."
msgstr "Desconfigura variáveis de ambiente existentes ao construir o novo ambiente, exceto aquelas especificadas com @option{--preserve} (veja abaixo). Isso tem o efeito de criar um ambiente no qual os caminhos de pesquisa contêm apenas entradas de pacote."

msgid "--preserve=@var{regexp}"
msgstr "--preserve=@var{regexp}"

msgid "-E @var{regexp}"
msgstr "-E @var{regexp}"

msgid "When used alongside @option{--pure}, preserve the environment variables matching @var{regexp}---in other words, put them on a ``white list'' of environment variables that must be preserved.  This option can be repeated several times."
msgstr "Quando usado junto com @option{--pure}, preserva as variáveis de ambiente que correspondem a @var{regexp}---em outras palavras, coloca-as em uma ``lista branca'' de variáveis de ambiente que devem ser preservadas. Esta opção pode ser repetida várias vezes."

msgid ""
"guix shell --pure --preserve=^SLURM openmpi @dots{} \\\n"
"  -- mpirun @dots{}\n"
msgstr ""
"guix shell --pure --preserve=^SLURM openmpi @dots{} \\\n"
"  -- mpirun @dots{}\n"

msgid "This example runs @command{mpirun} in a context where the only environment variables defined are @env{PATH}, environment variables whose name starts with @samp{SLURM}, as well as the usual ``precious'' variables (@env{HOME}, @env{USER}, etc.)."
msgstr "Este exemplo executa @command{mpirun} em um contexto onde as únicas variáveis de ambiente definidas são @env{PATH}, variáveis de ambiente cujo nome começa com @samp{SLURM}, bem como as variáveis ``preciosas'' usuais (@env{HOME}, @env{USER}, etc.)."

msgid "--search-paths"
msgstr "--search-paths"

msgid "Display the environment variable definitions that make up the environment."
msgstr "Exiba as definições de variáveis de ambiente que compõem o ambiente."

msgid "Attempt to build for @var{system}---e.g., @code{i686-linux}."
msgstr "Tente construir para @var{sistema}---por exemplo, @code{i686-linux}."

msgid "--container"
msgstr "--container"

msgid "-C"
msgstr "-C"

msgid "container"
msgstr "container"

msgid "Run @var{command} within an isolated container.  The current working directory outside the container is mapped inside the container.  Additionally, unless overridden with @option{--user}, a dummy home directory is created that matches the current user's home directory, and @file{/etc/passwd} is configured accordingly."
msgstr "Execute @var{comando} dentro de um contêiner isolado. O diretório de trabalho atual fora do contêiner é mapeado dentro do contêiner. Além disso, a menos que substituído por @option{--user}, um diretório pessoal (home) fictício é criado que corresponde ao diretório pessoal do usuário atual, e @file{/etc/passwd} é configurado adequadamente."

msgid "The spawned process runs as the current user outside the container.  Inside the container, it has the same UID and GID as the current user, unless @option{--user} is passed (see below)."
msgstr "O processo gerado é executado como o usuário atual fora do contêiner. Dentro do contêiner, ele tem o mesmo UID e GID que o usuário atual, a menos que @option{--user} seja passado (veja abaixo)."

msgid "--network"
msgstr "--network"

msgid "For containers, share the network namespace with the host system.  Containers created without this flag only have access to the loopback device."
msgstr "Para contêineres, compartilhe o namespace de rede com o sistema host. Os contêineres criados sem esse sinalizador têm acesso somente ao dispositivo de loopback."

msgid "--link-profile"
msgstr "--link-profile"

msgid "-P"
msgstr "-P"

msgid "For containers, link the environment profile to @file{~/.guix-profile} within the container and set @code{GUIX_ENVIRONMENT} to that.  This is equivalent to making @file{~/.guix-profile} a symlink to the actual profile within the container.  Linking will fail and abort the environment if the directory already exists, which will certainly be the case if @command{guix shell} was invoked in the user's home directory."
msgstr "Para contêineres, vincule o perfil do ambiente a @file{~/.guix-profile} dentro do contêiner e defina @code{GUIX_ENVIRONMENT} para isso. Isso é equivalente a tornar @file{~/.guix-profile} uma ligação simbólica para o perfil real dentro do contêiner. A vinculação falhará e abortará o ambiente se o diretório já existir, o que certamente será o caso se @command{guix shell} foi invocado no diretório pessoal do usuário."

msgid "Certain packages are configured to look in @file{~/.guix-profile} for configuration files and data;@footnote{For example, the @code{fontconfig} package inspects @file{~/.guix-profile/share/fonts} for additional fonts.} @option{--link-profile} allows these programs to behave as expected within the environment."
msgstr "Certos pacotes são configurados para procurar em @file{~/.guix-profile} por arquivos de configuração e dados;@footnote{Por exemplo, o pacote @code{fontconfig} inspeciona @file{~/.guix-profile/share/fonts} por fontes adicionais.} @option{--link-profile} permite que esses programas se comportem conforme o esperado no ambiente."

msgid "--user=@var{user}"
msgstr "--user=@var{usuário}"

msgid "-u @var{user}"
msgstr "-u @var{usuário}"

msgid "For containers, use the username @var{user} in place of the current user.  The generated @file{/etc/passwd} entry within the container will contain the name @var{user}, the home directory will be @file{/home/@var{user}}, and no user GECOS data will be copied.  Furthermore, the UID and GID inside the container are 1000.  @var{user} need not exist on the system."
msgstr "Para contêineres, use o nome de usuário @var{usuário} no lugar do usuário atual. A entrada @file{/etc/passwd} gerada dentro do contêiner conterá o nome @var{usuário}, o diretório pessoal será @file{/home/@var{usuário}} e nenhum dado GECOS do usuário será copiado. Além disso, o UID e o GID dentro do contêiner são 1000. @var{usuário} não precisa existir no sistema."

msgid "Additionally, any shared or exposed path (see @option{--share} and @option{--expose} respectively) whose target is within the current user's home directory will be remapped relative to @file{/home/USER}; this includes the automatic mapping of the current working directory."
msgstr "Além disso, qualquer caminho compartilhado ou exposto (veja @option{--share} e @option{--expose} respectivamente) cujo destino esteja dentro do pessoal do usuário atual será remapeado em relação a @file{/home/USUÁRIO}; isso inclui o mapeamento automático do diretório de trabalho atual."

msgid "While this will limit the leaking of user identity through home paths and each of the user fields, this is only one useful component of a broader privacy/anonymity solution---not one in and of itself."
msgstr "Embora isso limite o vazamento da identidade do usuário por meio de caminhos iniciais e de cada um dos campos do usuário, esse é apenas um componente útil de uma solução mais ampla de privacidade/anonimato — não uma solução em si."

msgid "--no-cwd"
msgstr "--no-cwd"

msgid "For containers, the default behavior is to share the current working directory with the isolated container and immediately change to that directory within the container.  If this is undesirable, @option{--no-cwd} will cause the current working directory to @emph{not} be automatically shared and will change to the user's home directory within the container instead.  See also @option{--user}."
msgstr "Para contêineres, o comportamento padrão é compartilhar o diretório de trabalho atual com o contêiner isolado e mudar imediatamente para esse diretório dentro do contêiner. Se isso for indesejável, @option{--no-cwd} fará com que o diretório de trabalho atual @emph{não} seja compartilhado automaticamente e mudará para o diretório pessoal do usuário dentro do contêiner. Veja também @option{--user}."

msgid "--expose=@var{source}[=@var{target}]"
msgstr "--expose=@var{fonte}[=@var{alvo}]"

msgid "--share=@var{source}[=@var{target}]"
msgstr "--share=@var{fonte}[=@var{alvo}]"

msgid "For containers, @option{--expose} (resp. @option{--share}) exposes the file system @var{source} from the host system as the read-only (resp. writable) file system @var{target} within the container.  If @var{target} is not specified, @var{source} is used as the target mount point in the container."
msgstr "Para contêineres, @option{--expose} (resp. @option{--share}) expõe o sistema de arquivos @var{fonte} do sistema host como o sistema de arquivos somente leitura (resp. gravável) @var{alvo} dentro do contêiner. Se @var{alvo} não for especificado, @var{fonte} será usado como o ponto de montagem de destino no contêiner."

msgid "The example below spawns a Guile REPL in a container in which the user's home directory is accessible read-only via the @file{/exchange} directory:"
msgstr "O exemplo abaixo gera um Guile REPL em um contêiner no qual o diretório pessoal do usuário é acessível somente para leitura por meio do diretório @file{/exchange}:"

msgid "guix shell --container --expose=$HOME=/exchange guile -- guile\n"
msgstr "guix shell --container --expose=$HOME=/exchange guile -- guile\n"

msgid "symbolic links, guix shell"
msgstr "ligações simbólicas, guix shell"

msgid "--symlink=@var{spec}"
msgstr "--symlink=@var{spec}"

msgid "-S @var{spec}"
msgstr "-S @var{spec}"

msgid "For containers, create the symbolic links specified by @var{spec}, as documented in @ref{pack-symlink-option}."
msgstr "Para contêineres, crie as ligações simbólicas especificadas por @var{spec}, conforme documentado em @ref{pack-symlink-option}."

msgid "file system hierarchy standard (FHS)"
msgstr "padrão de hierarquia do sistema de arquivos (FHS)"

msgid "FHS (file system hierarchy standard)"
msgstr "FHS (padrão de hierarquia do sistema de arquivos)"

msgid "--emulate-fhs"
msgstr "--emulate-fhs"

msgid "-F"
msgstr "-F"

msgid "When used with @option{--container}, emulate a @uref{https://refspecs.linuxfoundation.org/fhs.shtml, Filesystem Hierarchy Standard (FHS)} configuration within the container, providing @file{/bin}, @file{/lib}, and other directories and files specified by the FHS."
msgstr "Quando usado com @option{--container}, emule uma configuração do @uref{https://refspecs.linuxfoundation.org/fhs.shtml, padrão de hierarquia do sistema de arquivos (Filesystem Hierarchy Standard, FHS)} dentro do contêiner, fornecendo @file{/bin}, @file{/lib} e outros diretórios e arquivos especificados pelo FHS."

msgid "As Guix deviates from the FHS specification, this option sets up the container to more closely mimic that of other GNU/Linux distributions.  This is useful for reproducing other development environments, testing, and using programs which expect the FHS specification to be followed.  With this option, the container will include a version of glibc that will read @file{/etc/ld.so.cache} within the container for the shared library cache (contrary to glibc in regular Guix usage) and set up the expected FHS directories: @file{/bin}, @file{/etc}, @file{/lib}, and @file{/usr} from the container's profile."
msgstr "Como Guix desvia da especificação FHS, esta opção configura o contêiner para imitar mais de perto o de outras distribuições GNU/Linux. Isto é útil para reproduzir outros ambientes de desenvolvimento, testar e usar programas que esperam que a especificação FHS seja seguida. Com esta opção, o contêiner incluirá uma versão do glibc que lerá @file{/etc/ld.so.cache} dentro do contêiner para o cache da biblioteca compartilhada (ao contrário do glibc no uso regular do Guix) e configurará os diretórios FHS esperados: @file{/bin}, @file{/etc}, @file{/lib} e @file{/usr} do perfil do contêiner."

msgid "nested containers, for @command{guix shell}"
msgstr "contêineres aninhados, para @command{guix shell}"

msgid "container nesting, for @command{guix shell}"
msgstr "aninhamento de contêineres, para @command{guix shell}"

msgid "--nesting"
msgstr "--nesting"

msgid "-W"
msgstr "-W"

msgid "When used with @option{--container}, provide Guix @emph{inside} the container and arrange so that it can interact with the build daemon that runs outside the container.  This is useful if you want, within your isolated container, to create other containers, as in this sample session:"
msgstr "Quando usado com @option{--container}, forneça Guix @emph{dentro} do contêiner e organize para que ele possa interagir com o daemon de construção que roda fora do contêiner. Isso é útil se você quiser, dentro do seu contêiner isolado, criar outros contêineres, como nesta sessão de exemplo:"

msgid ""
"$ guix shell -CW coreutils\n"
"[env]$ guix shell -C guile -- guile -c '(display \"hello!\\n\")'\n"
"hello!\n"
"[env]$ exit\n"
msgstr ""
"$ guix shell -CW coreutils\n"
"[env]$ guix shell -C guile -- guile -c '(display \"olá!\\n\")'\n"
"olá!\n"
"[env]$ exit\n"

msgid "The session above starts a container with @code{coreutils} programs available in @env{PATH}.  From there, we spawn @command{guix shell} to create a @emph{nested} container that provides nothing but Guile."
msgstr "A sessão acima inicia um contêiner com programas @code{coreutils} disponíveis em @env{PATH}. A partir daí, geramos @command{guix shell} para criar um contêiner @emph{aninhado} que fornece nada além de Guile."

msgid "Another example is evaluating a @file{guix.scm} file that is untrusted, as shown here:"
msgstr "Outro exemplo é avaliar um arquivo @file{guix.scm} que não é confiável, conforme mostrado aqui:"

msgid "guix shell -CW -- guix build -f guix.scm\n"
msgstr "guix shell -CW -- guix build -f guix.scm\n"

msgid "The @command{guix build} command as executed above can only access the current directory."
msgstr "O comando @command{guix build} executado acima só pode acessar o diretório atual."

msgid "Under the hood, the @option{-W} option does several things:"
msgstr "Nos bastidores, a opção @option{-W} faz várias coisas:"

msgid "map the daemon's socket (by default @file{/var/guix/daemon-socket/socket}) inside the container;"
msgstr "mapeia o socket do daemon (por padrão, @file{/var/guix/daemon-socket/socket}) dentro do contêiner;"

msgid "map the whole store (by default @file{/gnu/store}) inside the container such that store items made available by nested @command{guix} invocations are visible;"
msgstr "mapeia todo o armazém (por padrão @file{/gnu/store}) dentro do contêiner de forma que os itens do armazém disponibilizados por invocações aninhadas @command{guix} sejam visíveis;"

msgid "add the currently-used @command{guix} command to the profile in the container, such that @command{guix describe} returns the same state inside and outside the container;"
msgstr "adiciona o comando @command{guix} usado atualmente ao perfil no contêiner, de modo que @command{guix describe} retorne o mesmo estado dentro e fora do contêiner;"

msgid "share the cache (by default @file{~/.cache/guix}) with the host, to speed up operations such as @command{guix time-machine} and @command{guix shell}."
msgstr "compartilha o cache (por padrão @file{~/.cache/guix}) com o host, para acelerar operações como @command{guix time-machine} e @command{guix shell}."

msgid "--rebuild-cache"
msgstr "--rebuild-cache"

msgid "caching, of profiles"
msgstr "cache, de perfis"

msgid "caching, in @command{guix shell}"
msgstr "caching, em @command{guix shell}"

msgid "In most cases, @command{guix shell} caches the environment so that subsequent uses are instantaneous.  Least-recently used cache entries are periodically removed.  The cache is also invalidated, when using @option{--file} or @option{--manifest}, anytime the corresponding file is modified."
msgstr "Na maioria dos casos, @command{guix shell} armazena em cache o ambiente para que os usos subsequentes sejam instantâneos. As entradas de cache menos usadas recentemente são removidas periodicamente. O cache também é invalidado, ao usar @option{--file} ou @option{--manifest}, sempre que o arquivo correspondente for modificado."

msgid "The @option{--rebuild-cache} forces the cached environment to be refreshed.  This is useful when using @option{--file} or @option{--manifest} and the @command{guix.scm} or @command{manifest.scm} file has external dependencies, or if its behavior depends, say, on environment variables."
msgstr "O @option{--rebuild-cache} força o ambiente em cache a ser atualizado. Isso é útil ao usar @option{--file} ou @option{--manifest} e o arquivo @command{guix.scm} ou @command{manifest.scm} tem dependências externas, ou se seu comportamento depende, digamos, de variáveis de ambiente."

msgid "--root=@var{file}"
msgstr "--root=@var{arquivo}"

msgid "-r @var{file}"
msgstr "-r @var{arquivo}"

msgid "persistent environment"
msgstr "ambiente persistente"

msgid "garbage collector root, for environments"
msgstr "coletor de lixo raiz, para ambientes"

msgid "Make @var{file} a symlink to the profile for this environment, and register it as a garbage collector root."
msgstr "Crie @var{arquivo} como uma ligação simbólica para o perfil deste ambiente e registre-a como raiz do coletor de lixo."

msgid "This is useful if you want to protect your environment from garbage collection, to make it ``persistent''."
msgstr "Isso é útil se você deseja proteger seu ambiente da coleta de lixo, para torná-lo ``persistente''."

msgid "When this option is omitted, @command{guix shell} caches profiles so that subsequent uses of the same environment are instantaneous---this is comparable to using @option{--root} except that @command{guix shell} takes care of periodically removing the least-recently used garbage collector roots."
msgstr "Quando esta opção é omitida, @command{guix shell} armazena em cache os perfis para que os usos subsequentes do mesmo ambiente sejam instantâneos — isso é comparável ao uso de @option{--root}, exceto que @command{guix shell} cuida da remoção periódica das raízes do coletor de lixo menos usadas recentemente."

msgid "In some cases, @command{guix shell} does not cache profiles---e.g., if transformation options such as @option{--with-latest} are used.  In those cases, the environment is protected from garbage collection only for the duration of the @command{guix shell} session.  This means that next time you recreate the same environment, you could have to rebuild or re-download packages."
msgstr "Em alguns casos, @command{guix shell} não armazena perfis em cache---por exemplo, se opções de transformação como @option{--with-latest} forem usadas. Nesses casos, o ambiente é protegido da coleta de lixo somente durante a sessão @command{guix shell}. Isso significa que na próxima vez que você recriar o mesmo ambiente, poderá ter que reconstruir ou baixar novamente os pacotes."

msgid "@xref{Invoking guix gc}, for more on GC roots."
msgstr "@xref{Invoking guix pack}, para mais sobre as raízes do coletor de lixo."

msgid "@command{guix shell} also supports all of the common build options that @command{guix build} supports (@pxref{Common Build Options}) as well as package transformation options (@pxref{Package Transformation Options})."
msgstr "@command{guix shell} também suporta todas as opções de compilação comuns que @command{guix build} suporta (@pxref{Common Build Options}), bem como opções de transformação de pacotes (@pxref{Package Transformation Options})."

msgid "Invoking @command{guix environment}"
msgstr "Invocando @command{guix environment}"

msgid "The purpose of @command{guix environment} is to assist in creating development environments."
msgstr "O objetivo do @command{guix environment} é auxiliar na criação de ambientes de desenvolvimento."

msgid "Deprecation warning"
msgstr "Aviso de descontinuação"

msgid "The @command{guix environment} command is deprecated in favor of @command{guix shell}, which performs similar functions but is more convenient to use.  @xref{Invoking guix shell}."
msgstr "O comando @command{guix environment} foi descontinuado em favor do @command{guix shell}, que executa funções semelhantes, mas é mais conveniente de usar. @xref{Invoking guix shell}."

msgid "Being deprecated, @command{guix environment} is slated for eventual removal, but the Guix project is committed to keeping it until May 1st, 2023.  Please get in touch with us at @email{guix-devel@@gnu.org} if you would like to discuss it."
msgstr "Sendo obsoleto, o @command{guix environment} está programado para remoção futura, mas o projeto Guix está comprometido em mantê-lo até 1º de maio de 2023. Entre em contato conosco pelo e-mail @email{guix-devel@@gnu.org} se quiser discutir o assunto."

msgid "guix environment @var{options} @var{package}@dots{}\n"
msgstr "guix environment @var{opções} @var{pacote}@dots{}\n"

msgid "The following example spawns a new shell set up for the development of GNU@tie{}Guile:"
msgstr "O exemplo a seguir gera uma nova configuração de shell para o desenvolvimento do GNU@tie{}Guile:"

msgid "guix environment guile\n"
msgstr "guix environment guile\n"

msgid "If the needed dependencies are not built yet, @command{guix environment} automatically builds them.  The environment of the new shell is an augmented version of the environment that @command{guix environment} was run in.  It contains the necessary search paths for building the given package added to the existing environment variables.  To create a ``pure'' environment, in which the original environment variables have been unset, use the @option{--pure} option@footnote{Users sometimes wrongfully augment environment variables such as @env{PATH} in their @file{~/.bashrc} file.  As a consequence, when @command{guix environment} launches it, Bash may read @file{~/.bashrc}, thereby introducing ``impurities'' in these environment variables.  It is an error to define such environment variables in @file{.bashrc}; instead, they should be defined in @file{.bash_profile}, which is sourced only by log-in shells.  @xref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}, for details on Bash start-up files.}."
msgstr "Se as dependências necessárias ainda não foram construídas, @command{guix environment} as constrói automaticamente. O ambiente do novo shell é uma versão aumentada do ambiente em que @command{guix environment} foi executado. Ele contém os caminhos de pesquisa necessários para construir o pacote fornecido adicionado às variáveis de ambiente existentes. Para criar um ambiente ``puro'', no qual as variáveis de ambiente originais foram desconfiguradas, use a opção @option{--pure}@footnote{Às vezes, os usuários aumentam incorretamente as variáveis de ambiente, como @env{PATH} em seu arquivo @file{~/.bashrc}. Como consequência, quando @command{guix environment} o inicia, o Bash pode ler @file{~/.bashrc}, introduzindo assim ``impurezas'' nessas variáveis de ambiente. É um erro definir essas variáveis de ambiente em @file{.bashrc}; em vez disso, elas devem ser definidas em @file{.bash_profile}, que é originado apenas por shells de login. @xref{Bash Startup Files,,, bash, Manual de referência do GNU Bash}, para detalhes sobre os arquivos de inicialização do Bash.}."

msgid "Exiting from a Guix environment is the same as exiting from the shell, and will place the user back in the old environment before @command{guix environment} was invoked.  The next garbage collection (@pxref{Invoking guix gc}) will clean up packages that were installed from within the environment and are no longer used outside of it."
msgstr "Sair de um ambiente Guix é o mesmo que sair do shell, e colocará o usuário de volta no ambiente antigo antes de @command{guix environment} ser invocado. A próxima coleta de lixo (@pxref{Invoking guix gc}) limpará os pacotes que foram instalados de dentro do ambiente e não são mais usados fora dele."

msgid "@command{guix environment} defines the @env{GUIX_ENVIRONMENT} variable in the shell it spawns; its value is the file name of the profile of this environment.  This allows users to, say, define a specific prompt for development environments in their @file{.bashrc} (@pxref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}):"
msgstr "@command{guix environment} define a variável @env{GUIX_ENVIRONMENT} no shell que ele gera; seu valor é o nome do arquivo do perfil deste ambiente. Isso permite que os usuários, digamos, definam um prompt específico para ambientes de desenvolvimento em seu @file{.bashrc} (@pxref{Bash Startup Files,,, bash, Manual de referência do GNU Bash}):"

msgid "Additionally, more than one package may be specified, in which case the union of the inputs for the given packages are used.  For example, the command below spawns a shell where all of the dependencies of both Guile and Emacs are available:"
msgstr "Além disso, mais de um pacote pode ser especificado, em cujo caso a união das entradas para os pacotes fornecidos é usada. Por exemplo, o comando abaixo gera um shell onde todas as dependências do Guile e do Emacs estão disponíveis:"

msgid "guix environment guile emacs\n"
msgstr "guix environment guile emacs\n"

msgid "Sometimes an interactive shell session is not desired.  An arbitrary command may be invoked by placing the @code{--} token to separate the command from the rest of the arguments:"
msgstr "Às vezes, uma sessão de shell interativa não é desejada. Um comando arbitrário pode ser invocado colocando o token @code{--} para separar o comando do resto dos argumentos:"

msgid "guix environment guile -- make -j4\n"
msgstr "guix environment guile -- make -j4\n"

msgid "In other situations, it is more convenient to specify the list of packages needed in the environment.  For example, the following command runs @command{python} from an environment containing Python@tie{}3 and NumPy:"
msgstr "Em outras situações, é mais conveniente especificar a lista de pacotes necessários no ambiente. Por exemplo, o comando a seguir executa @command{python} de um ambiente contendo Python@tie{}3 e NumPy:"

msgid "guix environment --ad-hoc python-numpy python -- python3\n"
msgstr "guix environment --ad-hoc python-numpy python -- python3\n"

msgid "Furthermore, one might want the dependencies of a package and also some additional packages that are not build-time or runtime dependencies, but are useful when developing nonetheless.  Because of this, the @option{--ad-hoc} flag is positional.  Packages appearing before @option{--ad-hoc} are interpreted as packages whose dependencies will be added to the environment.  Packages appearing after are interpreted as packages that will be added to the environment directly.  For example, the following command creates a Guix development environment that additionally includes Git and strace:"
msgstr "Além disso, pode-se querer as dependências de um pacote e também alguns pacotes adicionais que não são dependências de tempo de construção ou tempo de execução, mas são úteis ao desenvolver, no entanto. Por causa disso, o sinalizador @option{--ad-hoc} é posicional. Pacotes que aparecem antes de @option{--ad-hoc} são interpretados como pacotes cujas dependências serão adicionadas ao ambiente. Pacotes que aparecem depois são interpretados como pacotes que serão adicionados ao ambiente diretamente. Por exemplo, o comando a seguir cria um ambiente de desenvolvimento Guix que inclui adicionalmente Git e strace:"

msgid "guix environment --pure guix --ad-hoc git strace\n"
msgstr "guix environment --pure guix --ad-hoc git strace\n"

msgid "Sometimes it is desirable to isolate the environment as much as possible, for maximal purity and reproducibility.  In particular, when using Guix on a host distro that is not Guix System, it is desirable to prevent access to @file{/usr/bin} and other system-wide resources from the development environment.  For example, the following command spawns a Guile REPL in a ``container'' where only the store and the current working directory are mounted:"
msgstr "Às vezes, é desejável isolar o ambiente o máximo possível, para máxima pureza e reprodutibilidade. Em particular, ao usar Guix em uma distribuição host que não seja Guix System, é desejável impedir o acesso a @file{/usr/bin} e outros recursos de todo o sistema do ambiente de desenvolvimento. Por exemplo, o comando a seguir gera um Guile REPL em um ``contêiner'' onde apenas o armazém e o diretório de trabalho atual são montados:"

msgid "guix environment --ad-hoc --container guile -- guile\n"
msgstr "guix environment --ad-hoc --container guile -- guile\n"

msgid "The @option{--container} option requires Linux-libre 3.19 or newer."
msgstr "A opção @option{--container} requer Linux-libre 3.19 ou mais recente."

msgid "certificates"
msgstr "certificados"

msgid "Another typical use case for containers is to run security-sensitive applications such as a web browser.  To run Eolie, we must expose and share some files and directories; we include @code{nss-certs} and expose @file{/etc/ssl/certs/} for HTTPS authentication; finally we preserve the @env{DISPLAY} environment variable since containerized graphical applications won't display without it."
msgstr "Outro caso de uso típico para contêineres é executar aplicativos sensíveis à segurança, como um navegador da web. Para executar o Eolie, precisamos expor e compartilhar alguns arquivos e diretórios; incluímos @code{nss-certs} e expomos @file{/etc/ssl/certs/} para autenticação HTTPS; finalmente, preservamos a variável de ambiente @env{DISPLAY}, pois os aplicativos gráficos em contêiner não serão exibidos sem ela."

msgid ""
"guix environment --preserve='^DISPLAY$' --container --network \\\n"
"  --expose=/etc/machine-id \\\n"
"  --expose=/etc/ssl/certs/ \\\n"
"  --share=$HOME/.local/share/eolie/=$HOME/.local/share/eolie/ \\\n"
"  --ad-hoc eolie nss-certs dbus --  eolie\n"
msgstr ""
"guix environment --preserve='^DISPLAY$' --container --network \\\n"
"  --expose=/etc/machine-id \\\n"
"  --expose=/etc/ssl/certs/ \\\n"
"  --share=$HOME/.local/share/eolie/=$HOME/.local/share/eolie/ \\\n"
"  --ad-hoc eolie nss-certs dbus --  eolie\n"

msgid "Set up the environment and check whether the shell would clobber environment variables.  @xref{Invoking guix shell, @option{--check}}, for more info."
msgstr "Configure o ambiente e verifique se o shell sobrecarregaria as variáveis de ambiente. @xref{Invoking guix shell, @option{--check}}, para mais informações."

msgid "When this option is omitted, the environment is protected from garbage collection only for the duration of the @command{guix environment} session.  This means that next time you recreate the same environment, you could have to rebuild or re-download packages.  @xref{Invoking guix gc}, for more on GC roots."
msgstr "Quando esta opção pe omitida, o ambiente é protegido da coleta de lixo apenas pela duração da sessão do @command{guix environment}.  Isso significa que na próxima vez que você recriar o mesmo ambiente, você tpoderia ter que reconstruir ou refazer o download dos pacotes.  @xref{Invoking guix gc}, para mais sobre GC roots."

msgid "guix environment -e '(@@ (gnu packages maths) petsc-openmpi)'\n"
msgstr "guix environment -e '(@@ (gnu packages maths) petsc-openmpi)'\n"

msgid "guix environment --ad-hoc -e '(@@ (gnu) %base-packages)'\n"
msgstr "guix environment --ad-hoc -e '(@@ (gnu) %base-packages)'\n"

msgid "guix environment --ad-hoc -e '(list (@@ (gnu packages bash) bash) \"include\")'\n"
msgstr "guix environment --ad-hoc -e '(list (@@ (gnu packages bash) bash) \"include\")'\n"

msgid "--load=@var{file}"
msgstr "--load=@var{arquivo}"

msgid "-l @var{file}"
msgstr "-l @var{arquivo}"

msgid "Create an environment for the package or list of packages that the code within @var{file} evaluates to."
msgstr "Crie um ambiente para o pacote ou lista de pacotes que o código dentro de @var{arquivo} avalia."

msgid "@xref{shell-export-manifest, @command{guix shell --export-manifest}}, for information on how to ``convert'' command-line options into a manifest."
msgstr "@xref{shell-export-manifest, @command{guix shell --export-manifest}}, para obter informações sobre como ``converter'' opções de linha de comando em um manifesto."

msgid "--ad-hoc"
msgstr "--ad-hoc"

msgid "Include all specified packages in the resulting environment, as if an @i{ad hoc} package were defined with them as inputs.  This option is useful for quickly creating an environment without having to write a package expression to contain the desired inputs."
msgstr "Inclui todos os pacotes especificados no ambiente resultante, como se um pacote @i{ad hoc} fosse definido com eles como entradas. Esta opção é útil para criar rapidamente um ambiente sem ter que escrever uma expressão de pacote para conter as entradas desejadas."

msgid "For instance, the command:"
msgstr "Por exemplo, o comando:"

msgid "guix environment --ad-hoc guile guile-sdl -- guile\n"
msgstr "guix environment --ad-hoc guile guile-sdl -- guile\n"

msgid "runs @command{guile} in an environment where Guile and Guile-SDL are available."
msgstr "executa @command{guile} em um ambiente onde Guile e Guile-SDL estão disponíveis."

msgid "Note that this example implicitly asks for the default output of @code{guile} and @code{guile-sdl}, but it is possible to ask for a specific output---e.g., @code{glib:bin} asks for the @code{bin} output of @code{glib} (@pxref{Packages with Multiple Outputs})."
msgstr "Observe que este exemplo solicita implicitamente a saída padrão de @code{guile} e @code{guile-sdl}, mas é possível solicitar uma saída específica — por exemplo, @code{glib:bin} solicita a saída @code{bin} de @code{glib} (@pxref{Packages with Multiple Outputs})."

msgid "This option may be composed with the default behavior of @command{guix environment}.  Packages appearing before @option{--ad-hoc} are interpreted as packages whose dependencies will be added to the environment, the default behavior.  Packages appearing after are interpreted as packages that will be added to the environment directly."
msgstr "Esta opção pode ser composta com o comportamento padrão de @command{guix environment}. Pacotes que aparecem antes de @option{--ad-hoc} são interpretados como pacotes cujas dependências serão adicionadas ao ambiente, o comportamento padrão. Pacotes que aparecem depois são interpretados como pacotes que serão adicionados ao ambiente diretamente."

msgid ""
"guix environment --pure --preserve=^SLURM --ad-hoc openmpi @dots{} \\\n"
"  -- mpirun @dots{}\n"
msgstr ""
"guix environment --pure --preserve=^SLURM --ad-hoc openmpi @dots{} \\\n"
"  -- mpirun @dots{}\n"

msgid "For containers, link the environment profile to @file{~/.guix-profile} within the container and set @code{GUIX_ENVIRONMENT} to that.  This is equivalent to making @file{~/.guix-profile} a symlink to the actual profile within the container.  Linking will fail and abort the environment if the directory already exists, which will certainly be the case if @command{guix environment} was invoked in the user's home directory."
msgstr "Para contêineres, vincule o perfil do ambiente a @file{~/.guix-profile} dentro do contêiner e defina @code{GUIX_ENVIRONMENT} para isso. Isso é equivalente a tornar @file{~/.guix-profile} uma ligação simbólica para o perfil real dentro do contêiner. A vinculação falhará e abortará o ambiente se o diretório já existir, o que certamente será o caso se @command{guix environment} foi invocado no diretório pessoal do usuário."

msgid "guix environment --container --expose=$HOME=/exchange --ad-hoc guile -- guile\n"
msgstr "guix environment --container --expose=$HOME=/exchange --ad-hoc guile -- guile\n"

msgid "For containers, emulate a Filesystem Hierarchy Standard (FHS)  configuration within the container, see @uref{https://refspecs.linuxfoundation.org/fhs.shtml, the official specification}.  As Guix deviates from the FHS specification, this option sets up the container to more closely mimic that of other GNU/Linux distributions.  This is useful for reproducing other development environments, testing, and using programs which expect the FHS specification to be followed.  With this option, the container will include a version of @code{glibc} which will read @code{/etc/ld.so.cache} within the container for the shared library cache (contrary to @code{glibc} in regular Guix usage) and set up the expected FHS directories: @code{/bin}, @code{/etc}, @code{/lib}, and @code{/usr} from the container's profile."
msgstr "Para contêineres, emule uma configuração Filesystem Hierarchy Standard (FHS) dentro do contêiner, veja @uref{https://refspecs.linuxfoundation.org/fhs.shtml, a especificação oficial}. Como o Guix se desvia da especificação FHS, esta opção configura o contêiner para imitar mais de perto o de outras distribuições GNU/Linux. Isto é útil para reproduzir outros ambientes de desenvolvimento, testar e usar programas que esperam que a especificação FHS seja seguida. Com esta opção, o contêiner incluirá uma versão de @code{glibc} que lerá @code{/etc/ld.so.cache} dentro do contêiner para o cache da biblioteca compartilhada (ao contrário de @code{glibc} no uso regular do Guix) e configurará os diretórios FHS esperados: @code{/bin}, @code{/etc}, @code{/lib} e @code{/usr} do perfil do contêiner."

msgid "@command{guix environment} also supports all of the common build options that @command{guix build} supports (@pxref{Common Build Options}) as well as package transformation options (@pxref{Package Transformation Options})."
msgstr "@command{guix environment} também oferece suporte a todas as opções de compilação comuns que @command{guix build} oferece suporte (@pxref{Common Build Options}), bem como opções de transformação de pacotes (@pxref{Package Transformation Options})."

msgid "Invoking @command{guix pack}"
msgstr "Invocando @command{guix pack}"

msgid "guix pack"
msgstr "guix pack"

msgid "Occasionally you want to pass software to people who are not (yet!)  lucky enough to be using Guix.  You'd tell them to run @command{guix package -i @var{something}}, but that's not possible in this case.  This is where @command{guix pack} comes in."
msgstr "Ocasionalmente você quer passar software para pessoas que não têm (ainda!) a sorte de usar Guix. Você diria para elas executarem @command{guix package -i @var{algo}}, mas isso não é possível neste caso. É aqui que @command{guix pack} entra."

msgid "If you are looking for ways to exchange binaries among machines that already run Guix, @pxref{Invoking guix copy}, @ref{Invoking guix publish}, and @ref{Invoking guix archive}."
msgstr "Se você estiver procurando maneiras de trocar binários entre máquinas que já executam Guix, @pxref{Invoking guix copy}, @ref{Invoking guix publish} e @ref{Invoking guix archive}."

msgid "pack"
msgstr "pack"

msgid "bundle"
msgstr "embalagem"

msgid "application bundle"
msgstr "embalagem de aplicativos"

msgid "software bundle"
msgstr "embalagem de software"

msgid "The @command{guix pack} command creates a shrink-wrapped @dfn{pack} or @dfn{software bundle}: it creates a tarball or some other archive containing the binaries of the software you're interested in, and all its dependencies.  The resulting archive can be used on any machine that does not have Guix, and people can run the exact same binaries as those you have with Guix.  The pack itself is created in a bit-reproducible fashion, so anyone can verify that it really contains the build results that you pretend to be shipping."
msgstr "O comando @command{guix pack} cria uma @dfn{embalagem de software} encapsulado: ele cria um tarball ou algum outro arquivo contendo os binários do software em que você está interessado e todas as suas dependências. O arquivo resultante pode ser usado em qualquer máquina que não tenha Guix, e as pessoas podem executar exatamente os mesmos binários que você tem com Guix. A embalagem em si é criada de forma reproduzível em bits, para que qualquer um possa verificar se ela realmente contém os resultados da compilação que você pretende enviar."

msgid "For example, to create a bundle containing Guile, Emacs, Geiser, and all their dependencies, you can run:"
msgstr "Por exemplo, para criar uma embalagem contenda Guile, Emacs, Geiser e todas as suas dependências, você pode executar:"

msgid ""
"$ guix pack guile emacs emacs-geiser\n"
"@dots{}\n"
"/gnu/store/@dots{}-pack.tar.gz\n"
msgstr ""
"$ guix pack guile emacs emacs-geiser\n"
"@dots{}\n"
"/gnu/store/@dots{}-pack.tar.gz\n"

msgid "The result here is a tarball containing a @file{/gnu/store} directory with all the relevant packages.  The resulting tarball contains a @dfn{profile} with the three packages of interest; the profile is the same as would be created by @command{guix package -i}.  It is this mechanism that is used to create Guix's own standalone binary tarball (@pxref{Binary Installation})."
msgstr "O resultado aqui é um tarball contendo um diretório @file{/gnu/store} com todos os pacotes relevantes. O tarball resultante contém um @dfn{perfil} com os três pacotes de interesse; o perfil é o mesmo que seria criado por @command{guix package -i}. É esse mecanismo que é usado para criar o próprio tarball binário autônomo do Guix (@pxref{Binary Installation})."

msgid "Users of this pack would have to run @file{/gnu/store/@dots{}-profile/bin/guile} to run Guile, which you may find inconvenient.  To work around it, you can create, say, a @file{/opt/gnu/bin} symlink to the profile:"
msgstr "Usuários desta embalagem teriam que executar @file{/gnu/store/@dots{}-profile/bin/guile} para executar o Guile, o que você pode achar inconveniente. Para contornar isso, você pode criar, digamos, uma ligação simbólica @file{/opt/gnu/bin} para o perfil:"

msgid "guix pack -S /opt/gnu/bin=bin guile emacs emacs-geiser\n"
msgstr "guix pack -S /opt/gnu/bin=bin guile emacs emacs-geiser\n"

msgid "That way, users can happily type @file{/opt/gnu/bin/guile} and enjoy."
msgstr "Dessa forma, os usuários podem digitar @file{/opt/gnu/bin/guile} e aproveitar."

msgid "relocatable binaries, with @command{guix pack}"
msgstr "binários relocáveis, com @command{guix pack}"

msgid "What if the recipient of your pack does not have root privileges on their machine, and thus cannot unpack it in the root file system? In that case, you will want to use the @option{--relocatable} option (see below).  This option produces @dfn{relocatable binaries}, meaning they can be placed anywhere in the file system hierarchy: in the example above, users can unpack your tarball in their home directory and directly run @file{./opt/gnu/bin/guile}."
msgstr "E se o destinatário do sua embalagem não tiver privilégios de root na máquina dele e, portanto, não puder descompactá-lo no sistema de arquivos raiz? Nesse caso, você vai querer usar a opção @option{--relocatable} (veja abaixo). Essa opção produz @dfn{binários relocáveis}, o que significa que eles podem ser colocados em qualquer lugar na hierarquia do sistema de arquivos: no exemplo acima, os usuários podem descompactar seu tarball no diretório pessoal deles e executar diretamente @file{./opt/gnu/bin/guile}."

msgid "Docker, build an image with guix pack"
msgstr "Docker, construa uma imagem com guix pack"

msgid "Alternatively, you can produce a pack in the Docker image format using the following command:"
msgstr "Como alternativa, você pode produzir uma embalagem no formato de imagem do Docker usando o seguinte comando:"

msgid "guix pack -f docker -S /bin=bin guile guile-readline\n"
msgstr "guix pack -f docker -S /bin=bin guile guile-readline\n"

msgid "The result is a tarball that can be passed to the @command{docker load} command, followed by @code{docker run}:"
msgstr "O resultado é um tarball que pode ser passado para o comando @command{docker load}, seguido por @code{docker run}:"

msgid ""
"docker load < @var{file}\n"
"docker run -ti guile-guile-readline /bin/guile\n"
msgstr ""
"docker load < @var{arquivo}\n"
"docker run -ti guile-guile-readline /bin/guile\n"

msgid "where @var{file} is the image returned by @command{guix pack}, and @code{guile-guile-readline} is its ``image tag''.  See the @uref{https://docs.docker.com/engine/reference/commandline/load/, Docker documentation} for more information."
msgstr "onde @var{arquivo} é a imagem retornada por @command{guix pack}, e @code{guile-guile-readline} é sua ``image tag''. Veja @uref{https://docs.docker.com/engine/reference/commandline/load/, documentação do Docker} para mais informações."

msgid "Singularity, build an image with guix pack"
msgstr "Singularity, construa uma imagem com guix pack"

msgid "SquashFS, build an image with guix pack"
msgstr "SquashFS, construa uma imagem com guix pack"

msgid "Yet another option is to produce a SquashFS image with the following command:"
msgstr "Outra opção é produzir uma imagem SquashFS com o seguinte comando:"

msgid "guix pack -f squashfs bash guile emacs emacs-geiser\n"
msgstr "guix pack -f squashfs bash guile emacs emacs-geiser\n"

msgid "The result is a SquashFS file system image that can either be mounted or directly be used as a file system container image with the @uref{https://www.sylabs.io/docs/, Singularity container execution environment}, using commands like @command{singularity shell} or @command{singularity exec}."
msgstr "O resultado é uma imagem do sistema de arquivos SquashFS que pode ser montada ou usada diretamente como uma imagem de contêiner do sistema de arquivos com o @uref{https://www.sylabs.io/docs/, ambiente de execução do contêiner Singularity}, usando comandos como @command{singularity shell} ou @command{singularity exec}."

msgid "Another format internally based on SquashFS is @uref{https://appimage.org/, AppImage}. An AppImage file can be created and executed without any special privileges:"
msgstr "Outro formato internamente baseado em SquashFS é o @uref{https://appimage.org/, AppImage}. Um arquivo de AppImage pode ser criado e executado sem qualquer provilégio especial:"

msgid "Several command-line options allow you to customize your pack:"
msgstr "Várias opções de linha de comando permitem que você personalize sua embalagem:"

msgid "Produce a pack in the given @var{format}."
msgstr "Produza uma embalagem no @var{formato} fornecido."

msgid "The available formats are:"
msgstr "Os formatos disponíveis são:"

msgid "tarball"
msgstr "tarball"

msgid "This is the default format.  It produces a tarball containing all the specified binaries and symlinks."
msgstr "Este é o formato padrão. Ele produz um tarball contendo todos os binários e ligações simbólicas especificados."

msgid "docker"
msgstr "docker"

msgid "This produces a tarball that follows the @uref{https://github.com/docker/docker/blob/master/image/spec/v1.2.md, Docker Image Specification}.  By default, the ``repository name'' as it appears in the output of the @command{docker images} command is computed from package names passed on the command line or in the manifest file.  Alternatively, the ``repository name'' can also be configured via the @option{--image-tag} option.  Refer to @option{--help-docker-format} for more information on such advanced options."
msgstr "Isso produz um tarball que segue o @uref{https://github.com/docker/docker/blob/master/image/spec/v1.2.md, Docker Image Specification}. Por padrão, o ``nome do repositório'' como aparece na saída do comando @command{docker images} é computado a partir de nomes de pacotes passados na linha de comando ou no arquivo manifesto. Como alternativa, o ``nome do repositório'' também pode ser configurado por meio da opção @option{--image-tag}. Consulte @option{--help-docker-format} para obter mais informações sobre essas opções avançadas."

msgid "squashfs"
msgstr "squashfs"

msgid "This produces a SquashFS image containing all the specified binaries and symlinks, as well as empty mount points for virtual file systems like procfs."
msgstr "Isso produz uma imagem SquashFS contendo todos os binários e ligações simbólicas especificados, bem como pontos de montagem vazios para sistemas de arquivos virtuais como procfs."

msgid "Singularity @emph{requires} you to provide @file{/bin/sh} in the image.  For that reason, @command{guix pack -f squashfs} always implies @code{-S /bin=bin}.  Thus, your @command{guix pack} invocation must always start with something like:"
msgstr "Singularity @emph{requer} que você forneça @file{/bin/sh} na imagem. Por esse motivo, @command{guix pack -f squashfs} sempre implica @code{-S /bin=bin}. Portanto, sua invocação @command{guix pack} deve sempre começar com algo como:"

msgid "guix pack -f squashfs bash @dots{}\n"
msgstr "guix pack -f squashfs bash @dots{}\n"

msgid "If you forget the @code{bash} (or similar) package, @command{singularity run} and @command{singularity exec} will fail with an unhelpful ``no such file or directory'' message."
msgstr "Se você esquecer o pacote @code{bash} (ou similar), @command{singularity run} e @command{singularity exec} falharão com uma mensagem inútil ``nenhum arquivo ou diretório''."

msgid "deb"
msgstr "deb"

msgid "Debian, build a .deb package with guix pack"
msgstr "Debian, construa um pacote .deb com guix pack"

msgid "This produces a Debian archive (a package with the @samp{.deb} file extension) containing all the specified binaries and symbolic links, that can be installed on top of any dpkg-based GNU(/Linux) distribution.  Advanced options can be revealed via the @option{--help-deb-format} option.  They allow embedding control files for more fine-grained control, such as activating specific triggers or providing a maintainer configure script to run arbitrary setup code upon installation."
msgstr "Isso produz um arquivo Debian (um pacote com a extensão de arquivo @samp{.deb}) contendo todos os binários e ligações simbólicas especificados, que podem ser instalados em cima de qualquer distribuição GNU(/Linux) baseada em dpkg. Opções avançadas podem ser reveladas por meio da opção @option{--help-deb-format}. Elas permitem incorporar arquivos de controle para um controle mais refinado, como ativar gatilhos específicos ou fornecer um script de configuração do mantenedor para executar código de configuração arbitrário na instalação."

msgid "guix pack -f deb -C xz -S /usr/bin/hello=bin/hello hello\n"
msgstr "guix pack -f deb -C xz -S /usr/bin/hello=bin/hello hello\n"

msgid "Because archives produced with @command{guix pack} contain a collection of store items and because each @command{dpkg} package must not have conflicting files, in practice that means you likely won't be able to install more than one such archive on a given system.  You can nonetheless pack as many Guix packages as you want in one such archive."
msgstr "Como os arquivos produzidos com @command{guix pack} contêm uma coleção de itens de armazém e como cada pacote @command{dpkg} não deve ter arquivos conflitantes, na prática isso significa que você provavelmente não conseguirá instalar mais de um desses arquivos em um dado sistema. Você pode, no entanto, empacotar quantos pacotes Guix quiser em um desses arquivos."

msgid "@command{dpkg} will assume ownership of any files contained in the pack that it does @emph{not} know about.  It is unwise to install Guix-produced @samp{.deb} files on a system where @file{/gnu/store} is shared by other software, such as a Guix installation or other, non-deb packs."
msgstr "@command{dpkg} assumirá a propriedade de quaisquer arquivos contidos no pacote que ele @emph{não} saiba. Não é sensato instalar arquivos @samp{.deb} produzidos pelo Guix em um sistema onde @file{/gnu/store} é compartilhado por outro software, como uma instalação do Guix ou outras embalagens não deb."

msgid "rpm"
msgstr "rpm"

msgid "RPM, build an RPM archive with guix pack"
msgstr "RPM, construa um arquivo RPM com guix pack"

msgid "This produces an RPM archive (a package with the @samp{.rpm} file extension) containing all the specified binaries and symbolic links, that can be installed on top of any RPM-based GNU/Linux distribution.  The RPM format embeds checksums for every file it contains, which the @command{rpm} command uses to validate the integrity of the archive."
msgstr "Isso produz um arquivo RPM (um pacote com a extensão de arquivo @samp{.rpm}) contendo todos os binários e ligações simbólicas especificados, que podem ser instalados em cima de qualquer distribuição GNU/Linux baseada em RPM. O formato RPM incorpora somas de verificação para cada arquivo que ele contém, que o comando @command{rpm} usa para validar a integridade do arquivo."

msgid "Advanced RPM-related options are revealed via the @option{--help-rpm-format} option.  These options allow embedding maintainer scripts that can run before or after the installation of the RPM archive, for example."
msgstr "Opções avançadas relacionadas a RPM são reveladas por meio da opção @option{--help-rpm-format}. Essas opções permitem incorporar scripts de mantenedor que podem ser executados antes ou depois da instalação do arquivo RPM, por exemplo."

msgid "The RPM format supports relocatable packages via the @option{--prefix} option of the @command{rpm} command, which can be handy to install an RPM package to a specific prefix."
msgstr "O formato RPM suporta pacotes relocáveis por meio da opção @option{--prefix} do comando @command{rpm}, o que pode ser útil para instalar um pacote RPM em um prefixo específico."

msgid "guix pack -f rpm -R -C xz -S /usr/bin/hello=bin/hello hello\n"
msgstr "guix pack -f rpm -R -C xz -S /usr/bin/hello=bin/hello hello\n"

msgid "sudo rpm --install --prefix=/opt /gnu/store/...-hello.rpm\n"
msgstr "sudo rpm --install --prefix=/opt /gnu/store/...-hello.rpm\n"

msgid "Contrary to Debian packages, conflicting but @emph{identical} files in RPM packages can be installed simultaneously, which means multiple @command{guix pack}-produced RPM packages can usually be installed side by side without any problem."
msgstr "Ao contrário dos pacotes Debian, arquivos conflitantes, mas @emph{idênticos} em pacotes RPM podem ser instalados simultaneamente, o que significa que vários pacotes RPM produzidos pelo @command{guix pack} geralmente podem ser instalados lado a lado sem nenhum problema."

msgid "@command{rpm} assumes ownership of any files contained in the pack, which means it will remove @file{/gnu/store} upon uninstalling a Guix-generated RPM package, unless the RPM package was installed with the @option{--prefix} option of the @command{rpm} command.  It is unwise to install Guix-produced @samp{.rpm} packages on a system where @file{/gnu/store} is shared by other software, such as a Guix installation or other, non-rpm packs."
msgstr "@command{rpm} assume a propriedade de quaisquer arquivos contidos no pacote, o que significa que ele removerá @file{/gnu/store} ao desinstalar um pacote RPM gerado pelo Guix, a menos que o pacote RPM tenha sido instalado com a opção @option{--prefix} do comando @command{rpm}. Não é sensato instalar pacotes @samp{.rpm} produzidos pelo Guix em um sistema onde @file{/gnu/store} é compartilhado por outro software, como uma instalação do Guix ou outras embalagens não rpm."

msgid "This produces an @uref{https://appimage.org/, AppImage file} with the @samp{.AppImage} extension.  AppImage is a SquashFS volume prefixed with a runtime that mounts the SquashFS file system and executes the binary provided with @option{--entry-point}.  This results in a self-contained archive that bundles the software and all its requirements into a single file.  When the file is made executable it runs the packaged software."
msgstr "Isto produz um @uref{https://appimage.org/, arquivo AppImage} com a extensão @samp{.AppImage}.  Um AppImage é um volume SquashFS prefixado com uma execução que monta o sistema de arquivo SquashFS e executa o binário criado com o @option{--entry-point}.  Isso resulta num arquivo auto-contido que agrupa o software e todos os requisitos num único arquivo.  Quando o mesmo é executado, ele roda o software empacotado."

msgid "The runtime used by AppImages invokes the @command{fusermount3} command to mount the image quickly.  If that command is unavailable, the AppImage fails to run, but it can still be started by passing the @option{--appimage-extract-and-run} flag."
msgstr "A execução usada pelos AppImages invoca o comando @command{fusermount3} para montar a imagem rapidamente.  Se o comando está indiponível, o AppImage falha em executar, mas ele ainda pode ser iniciado com a opção @option{--appimage-extract-and-run}."

msgid "When building an AppImage, always @emph{pass} the @option{--relocatable} option (or @option{-R}, or @option{-RR}) to make sure the image can be used on systems where Guix is not installed.  A warning is printed when this option is not used."
msgstr "Ao construir um AppImage, sempre @emph{passe} a opção @option{--relocatable} (ou @option{-R}, ou a @option{-RR}) para ter certeza que a imagem pode ser usada em sistemas onde o Guix não está instalado.  Um aviso é impresso quando esta opção não é usada."

msgid "relocatable binaries"
msgstr "binários realocáveis"

msgid "--relocatable"
msgstr "--relocatable"

msgid "Produce @dfn{relocatable binaries}---i.e., binaries that can be placed anywhere in the file system hierarchy and run from there."
msgstr "Produza @dfn{binários relocáveis}---ou seja, binários que podem ser colocados em qualquer lugar na hierarquia do sistema de arquivos e executados a partir daí."

msgid "When this option is passed once, the resulting binaries require support for @dfn{user namespaces} in the kernel Linux; when passed @emph{twice}@footnote{Here's a trick to memorize it: @code{-RR}, which adds PRoot support, can be thought of as the abbreviation of ``Really Relocatable''.  Neat, isn't it?}, relocatable binaries fall to back to other techniques if user namespaces are unavailable, and essentially work anywhere---see below for the implications."
msgstr "Quando essa opção é passada uma vez, os binários resultantes requerem suporte para @dfn{user namespaces} no kernel Linux; quando passada @emph{duas vezes}@footnote{Aqui vai um truque para memorizá-la: @code{-RR}, que adiciona suporte a PRoot, pode ser pensado como a abreviação de ``Really Relocatable''. Legal, não é?}, binários relocáveis recorrem a outras técnicas se os namespaces de usuário não estiverem disponíveis, e essencialmente funcionam em qualquer lugar---veja abaixo as implicações."

msgid "For example, if you create a pack containing Bash with:"
msgstr "Por exemplo, se você criar uma embalagem contendo Bash com:"

msgid "guix pack -RR -S /mybin=bin bash\n"
msgstr "guix pack -RR -S /mybin=bin bash\n"

msgid "...@: you can copy that pack to a machine that lacks Guix, and from your home directory as a normal user, run:"
msgstr "...@: você pode copiar essa embalagem para uma máquina que não tenha Guix e, a partir do seu diretório pessoal, como um usuário normal, executar:"

msgid ""
"tar xf pack.tar.gz\n"
"./mybin/sh\n"
msgstr ""
"tar xf pack.tar.gz\n"
"./mybin/sh\n"

msgid "In that shell, if you type @code{ls /gnu/store}, you'll notice that @file{/gnu/store} shows up and contains all the dependencies of @code{bash}, even though the machine actually lacks @file{/gnu/store} altogether! That is probably the simplest way to deploy Guix-built software on a non-Guix machine."
msgstr "Nesse shell, se você digitar @code{ls /gnu/store}, você notará que @file{/gnu/store} aparece e contém todas as dependências de @code{bash}, mesmo que a máquina realmente não tenha @file{/gnu/store} completamente! Essa é provavelmente a maneira mais simples de implementar software construído pelo Guix em uma máquina não Guix."

msgid "By default, relocatable binaries rely on the @dfn{user namespace} feature of the kernel Linux, which allows unprivileged users to mount or change root.  Old versions of Linux did not support it, and some GNU/Linux distributions turn it off."
msgstr "Por padrão, binários relocáveis dependem do recurso @dfn{user namespace} do kernel Linux, que permite que usuários sem privilégios montem ou alterem a raiz (chroot). Versões antigas do Linux não o suportavam, e algumas distribuições GNU/Linux o desativam."

msgid "To produce relocatable binaries that work even in the absence of user namespaces, pass @option{--relocatable} or @option{-R} @emph{twice}.  In that case, binaries will try user namespace support and fall back to another @dfn{execution engine} if user namespaces are not supported.  The following execution engines are supported:"
msgstr "Para produzir binários relocáveis que funcionam mesmo na ausência de namespaces de usuário, passe @option{--relocatable} ou @option{-R} @emph{duas vezes}. Nesse caso, os binários tentarão o suporte a namespaces de usuário e retornarão a outro @dfn{mecanismo de execução} se os namespaces de usuário não forem suportados. Os seguintes mecanismos de execução são suportados:"

msgid "default"
msgstr "default"

msgid "Try user namespaces and fall back to PRoot if user namespaces are not supported (see below)."
msgstr "Experimente usar namespaces de usuário e retorne ao PRoot se eles não forem suportados (veja abaixo)."

msgid "performance"
msgstr "performance"

msgid "Try user namespaces and fall back to Fakechroot if user namespaces are not supported (see below)."
msgstr "Experimente usar namespaces de usuário e retorne ao Fakechroot se eles não forem suportados (veja abaixo)."

msgid "userns"
msgstr "userns"

msgid "Run the program through user namespaces and abort if they are not supported."
msgstr "Execute o programa por meio de namespaces de usuário e aborte se eles não forem suportados."

msgid "proot"
msgstr "proot"

msgid "Run through PRoot.  The @uref{https://proot-me.github.io/, PRoot} program provides the necessary support for file system virtualization.  It achieves that by using the @code{ptrace} system call on the running program.  This approach has the advantage to work without requiring special kernel support, but it incurs run-time overhead every time a system call is made."
msgstr "Execute através do PRoot. O programa @uref{https://proot-me.github.io/, PRoot} fornece o suporte necessário para virtualização do sistema de arquivos. Ele consegue isso usando a chamada de sistema @code{ptrace} no programa em execução. Essa abordagem tem a vantagem de funcionar sem exigir suporte especial do kernel, mas incorre em sobrecarga de tempo de execução toda vez que uma chamada de sistema é feita."

msgid "fakechroot"
msgstr "fakechroot"

msgid "Run through Fakechroot.  @uref{https://github.com/dex4er/fakechroot/, Fakechroot} virtualizes file system accesses by intercepting calls to C library functions such as @code{open}, @code{stat}, @code{exec}, and so on.  Unlike PRoot, it incurs very little overhead.  However, it does not always work: for example, some file system accesses made from within the C library are not intercepted, and file system accesses made @i{via} direct syscalls are not intercepted either, leading to erratic behavior."
msgstr "Execute através do Fakechroot. @uref{https://github.com/dex4er/fakechroot/, Fakechroot} virtualiza acessos ao sistema de arquivos interceptando chamadas para funções da biblioteca C, como @code{open}, @code{stat}, @code{exec} e assim por diante. Ao contrário do PRoot, ele incorre em muito pouca sobrecarga. No entanto, nem sempre funciona: por exemplo, alguns acessos ao sistema de arquivos feitos de dentro da biblioteca C não são interceptados, e acessos ao sistema de arquivos feitos @i{via} syscalls diretas também não são interceptados, levando a um comportamento errático."

msgid "GUIX_EXECUTION_ENGINE"
msgstr "GUIX_EXECUTION_ENGINE"

msgid "When running a wrapped program, you can explicitly request one of the execution engines listed above by setting the @env{GUIX_EXECUTION_ENGINE} environment variable accordingly."
msgstr "Ao executar um programa encapsulado, você pode solicitar explicitamente um dos mecanismos de execução listados acima, definindo a variável de ambiente @env{GUIX_EXECUTION_ENGINE} adequadamente."

msgid "entry point, for Docker and Singularity images"
msgstr "ponto de entrada para imagens Docker e Singularity"

msgid "--entry-point=@var{command}"
msgstr "--entry-point=@var{comando}"

msgid "Use @var{command} as the @dfn{entry point} of the resulting pack, if the pack format supports it---currently @code{docker}, @code{appimage}, and @code{squashfs} (Singularity) support it.  @var{command} must be relative to the profile contained in the pack."
msgstr "Use @var{comando} como o @dfn{ponto de entrada} da embalagem resultante, se o formato da embalagem for compatível — atualmente, @code{docker}, @code{appimage} e @code{squashfs} (Singularity) o são. @var{comando} deve ser relativo ao perfil contido na embalagem."

msgid "The entry point specifies the command that tools like @code{docker run} or @code{singularity run} automatically start by default.  For example, you can do:"
msgstr "O ponto de entrada especifica o comando que ferramentas como @code{docker run} ou @code{singularity run} iniciam automaticamente por padrão. Por exemplo, você pode fazer:"

msgid "guix pack -f docker --entry-point=bin/guile guile\n"
msgstr "guix pack -f docker --entry-point=bin/guile guile\n"

msgid "The resulting pack can easily be loaded and @code{docker run} with no extra arguments will spawn @code{bin/guile}:"
msgstr "A embalagem resultante pode ser facilmente carregado e @code{docker run} sem argumentos extras irá gerar @code{bin/guile}:"

msgid ""
"docker load -i pack.tar.gz\n"
"docker run @var{image-id}\n"
msgstr ""
"docker load -i pack.tar.gz\n"
"docker run @var{image-id}\n"

msgid "entry point arguments, for docker images"
msgstr "argumentos de ponto de entrada, para imagens docker"

msgid "--entry-point-argument=@var{command}"
msgstr "--entry-point-argument=@var{comando}"

msgid "-A @var{command}"
msgstr "-A @var{comando}"

msgid "Use @var{command} as an argument to @dfn{entry point} of the resulting pack.  This option is only valid in conjunction with @code{--entry-point} and can appear multiple times on the command line."
msgstr "Use @var{comando} como um argumento para @dfn{o ponto de entrada} da embalagem resultante. Esta opção é válida somente em conjunto com @code{--entry-point} e pode aparecer várias vezes na linha de comando."

msgid "guix pack -f docker --entry-point=bin/guile --entry-point-argument=\"--help\" guile\n"
msgstr "guix pack -f docker --entry-point=bin/guile --entry-point-argument=\"--help\" guile\n"

msgid "maximum layers argument, for docker images"
msgstr "argumento de camadas máximas, para imagens docker"

msgid "--max-layers=@code{n}"
msgstr "--max-layers=@code{n}"

msgid "Specifies the maximum number of Docker image layers allowed when building an image."
msgstr "Especifica o número máximo de camadas de imagem do Docker permitidas ao criar uma imagem."

msgid "guix pack -f docker --max-layers=100 guile\n"
msgstr "guix pack -f docker --max-layers=100 guile\n"

msgid "This option allows you to limit the number of layers in a Docker image.  Docker images are comprised of multiple layers, and each layer adds to the overall size and complexity of the image.  By setting a maximum number of layers, you can control the following effects:"
msgstr "Esta opção permite que você limite o número de camadas em uma imagem Docker. As imagens Docker são compostas de várias camadas, e cada camada adiciona ao tamanho geral e à complexidade da imagem. Ao definir um número máximo de camadas, você pode controlar os seguintes efeitos:"

msgid "Disk Usage:"
msgstr "Uso do disco:"

msgid "Increasing the number of layers can help optimize the disk space required to store multiple images built with a similar package graph."
msgstr "Aumentar o número de camadas pode ajudar a otimizar o espaço em disco necessário para armazenar várias imagens criadas com um grafo de pacote semelhante."

msgid "Pulling:"
msgstr "Puxar:"

msgid "When transferring images between different nodes or systems, having more layers can reduce the time required to pull the image."
msgstr "Ao transferir imagens entre diferentes nós ou sistemas, ter mais camadas pode reduzir o tempo necessário para puxar a imagem."

msgid "Consider the package @var{expr} evaluates to."
msgstr "Considere o pacote que @var{expr} avalia."

msgid "This has the same purpose as the same-named option in @command{guix build} (@pxref{Additional Build Options, @option{--expression} in @command{guix build}})."
msgstr "Isso tem o mesmo propósito que a opção de mesmo nome em @command{guix build} (@pxref{Additional Build Options, @option{--expression} em @command{guix build}})."

msgid "pack-manifest"
msgstr "pack-manifest"

msgid "Use the packages contained in the manifest object returned by the Scheme code in @var{file}.  This option can be repeated several times, in which case the manifests are concatenated."
msgstr "Use os pacotes contidos no objeto manifesto retornado pelo código Scheme em @var{arquivo}. Esta opção pode ser repetida várias vezes, nesse caso os manifestos são concatenados."

msgid "This has a similar purpose as the same-named option in @command{guix package} (@pxref{profile-manifest, @option{--manifest}}) and uses the same manifest files.  It allows you to define a collection of packages once and use it both for creating profiles and for creating archives for use on machines that do not have Guix installed.  Note that you can specify @emph{either} a manifest file @emph{or} a list of packages, but not both."
msgstr "Isto tem um propósito similar à opção de mesmo nome em @command{guix package} (@pxref{profile-manifest, @option{--manifest}}) e usa os mesmos arquivos de manifesto. Ele permite que você defina uma coleção de pacotes uma vez e use-a tanto para criar perfis quanto para criar arquivos para uso em máquinas que não tenham o Guix instalado. Note que você pode especificar @emph{ou} um arquivo de manifesto @emph{ou} uma lista de pacotes, mas não ambos."

msgid "@xref{Writing Manifests}, for information on how to write a manifest.  @xref{shell-export-manifest, @command{guix shell --export-manifest}}, for information on how to ``convert'' command-line options into a manifest."
msgstr "@xref{Writing Manifests}, para obter informações sobre como escrever um manifesto. @xref{shell-export-manifest, @command{guix shell --export-manifest}}, para obter informações sobre como ``converter'' opções de linha de comando em um manifesto."

msgid "--target=@var{triplet}"
msgstr "--target=@var{tripleto}"

msgid "cross-compilation"
msgstr "compilação cruzada"

msgid "Cross-build for @var{triplet}, which must be a valid GNU triplet, such as @code{\"aarch64-linux-gnu\"} (@pxref{Specifying target triplets, GNU configuration triplets,, autoconf, Autoconf})."
msgstr "Construção cruzada para @var{tripleto}, que deve ser um tripleto GNU válido, como @code{\"aarch64-linux-gnu\"} (@pxref{Specifying target triplets, tripletos de configuração GNU, autoconf, Autoconf})."

msgid "--compression=@var{tool}"
msgstr "--compression=@var{ferramenta}"

msgid "-C @var{tool}"
msgstr "-C @var{ferramenta}"

msgid "Compress the resulting tarball using @var{tool}---one of @code{gzip}, @code{zstd}, @code{bzip2}, @code{xz}, @code{lzip}, or @code{none} for no compression."
msgstr "Compacte o tarball resultante usando @var{ferramenta}---um dos seguintes: @code{gzip}, @code{zstd}, @code{bzip2}, @code{xz}, @code{lzip} ou @code{none} para nenhuma compactação."

msgid "pack-symlink-option"
msgstr "pack-symlink-option"

msgid "Add the symlinks specified by @var{spec} to the pack.  This option can appear several times."
msgstr "Adicione os symlinks especificados por @var{spec} à embalagem. Esta opção pode aparecer várias vezes."

msgid "@var{spec} has the form @code{@var{source}=@var{target}}, where @var{source} is the symlink that will be created and @var{target} is the symlink target."
msgstr "@var{spec} tem o formato @code{@var{fonte}=@var{alvo}}, onde @var{fonte} é a ligação simbólica que será criado e @var{alvo} é o destino da ligação simbólica."

msgid "For instance, @code{-S /opt/gnu/bin=bin} creates a @file{/opt/gnu/bin} symlink pointing to the @file{bin} sub-directory of the profile."
msgstr "Por exemplo, @code{-S /opt/gnu/bin=bin} cria uma ligação simbólica @file{/opt/gnu/bin} apontanda para o subdiretório @file{bin} do perfil."

msgid "--save-provenance"
msgstr "--save-provenance"

msgid "Save provenance information for the packages passed on the command line.  Provenance information includes the URL and commit of the channels in use (@pxref{Channels})."
msgstr "Salvar informações de procedência para os pacotes passados na linha de comando. As informações de procedência incluem a URL e o commit dos canais em uso (@pxref{Channels})."

msgid "Provenance information is saved in the @file{/gnu/store/@dots{}-profile/manifest} file in the pack, along with the usual package metadata---the name and version of each package, their propagated inputs, and so on.  It is useful information to the recipient of the pack, who then knows how the pack was (supposedly) obtained."
msgstr "As informações de procedência são salvas no arquivo @file{/gnu/store/@dots{}-profile/manifest} na embalagem, junto com os metadados usuais do pacote --- o nome e a versão de cada pacote, suas entradas propagadas e assim por diante. São informações úteis para o destinatário da embalagem, que então sabe como a embalagem foi (supostamente) obtida."

msgid "This option is not enabled by default because, like timestamps, provenance information contributes nothing to the build process.  In other words, there is an infinity of channel URLs and commit IDs that can lead to the same pack.  Recording such ``silent'' metadata in the output thus potentially breaks the source-to-binary bitwise reproducibility property."
msgstr "Esta opção não é habilitada por padrão porque, assim como os timestamps, as informações de proveniência não contribuem em nada para o processo de construção. Em outras palavras, há uma infinidade de URLs de canais e IDs de commit que podem levar à mesma embalagem. Gravar esses metadados ``silenciosos'' na saída, portanto, potencialmente quebra a propriedade de reprodutibilidade bit a bit de origem para binário."

msgid "garbage collector root, for packs"
msgstr "raiz do coletor de lixo, para embalagens"

msgid "Make @var{file} a symlink to the resulting pack, and register it as a garbage collector root."
msgstr "Crie @var{arquivo} como uma ligação simbólica para a embalagem resultante e registre-a como uma raiz do coletor de lixo."

msgid "--localstatedir"
msgstr "--localstatedir"

msgid "--profile-name=@var{name}"
msgstr "--profile-name=@var{nome}"

msgid "Include the ``local state directory'', @file{/var/guix}, in the resulting pack, and notably the @file{/var/guix/profiles/per-user/root/@var{name}} profile---by default @var{name} is @code{guix-profile}, which corresponds to @file{~root/.guix-profile}."
msgstr "Inclua o ``diretório de estado local'', @file{/var/guix}, na embalagem resultante, e principalmente o perfil @file{/var/guix/profiles/per-user/root/@var{nome}} --- por padrão, @var{nome} é @code{guix-profile}, que corresponde a @file{~root/.guix-profile}."

msgid "@file{/var/guix} contains the store database (@pxref{The Store}) as well as garbage-collector roots (@pxref{Invoking guix gc}).  Providing it in the pack means that the store is ``complete'' and manageable by Guix; not providing it in the pack means that the store is ``dead'': items cannot be added to it or removed from it after extraction of the pack."
msgstr "@file{/var/guix} contém o banco de dados do armazém (@pxref{The Store}), bem como as raízes do coletor de lixo (@pxref{Invoking guix gc}). Fornecê-lo na embalagem significa que o armazém está ``completo'' e gerenciável pelo Guix; não fornecê-lo na embalagem significa que o armazém está ``morto'': itens não podem ser adicionados a ele ou removidos dele após a extração da embalagem."

msgid "One use case for this is the Guix self-contained binary tarball (@pxref{Binary Installation})."
msgstr "Um caso de uso para isso é o tarball binário independente do Guix (@pxref{Binary Installation})."

msgid "--derivation"
msgstr "--derivation"

msgid "-d"
msgstr "-d"

msgid "Print the name of the derivation that builds the pack."
msgstr "Exiba o nome da derivação que constrói a embalagem."

msgid "Use the bootstrap binaries to build the pack.  This option is only useful to Guix developers."
msgstr "Use os binários bootstrap para construir a embalagem. Esta opção é útil somente para desenvolvedores do Guix."

msgid "In addition, @command{guix pack} supports all the common build options (@pxref{Common Build Options}) and all the package transformation options (@pxref{Package Transformation Options})."
msgstr "Além disso, @command{guix pack} suporta todas as opções de compilação comuns (@pxref{Common Build Options}) e todas as opções de transformação de pacote (@pxref{Package Transformation Options})."

msgid "GCC"
msgstr "GCC"

msgid "ld-wrapper"
msgstr "ld-wrapper"

msgid "linker wrapper"
msgstr "envoltório do vinculador"

msgid "toolchain, for C development"
msgstr "cadeia de ferramentas, para desenvolvimento em C"

msgid "toolchain, for Fortran development"
msgstr "cadeia de ferramentas, para desenvolvimento Fortran"

msgid "If you need a complete toolchain for compiling and linking C or C++ source code, use the @code{gcc-toolchain} package.  This package provides a complete GCC toolchain for C/C++ development, including GCC itself, the GNU C Library (headers and binaries, plus debugging symbols in the @code{debug} output), Binutils, and a linker wrapper."
msgstr "Se você precisa de uma cadeia de ferramentas completa para compilar e vincular código-fonte C ou C++, use o pacote @code{gcc-toolchain}. Este pacote fornece uma cadeia de ferramentas GCC completa para desenvolvimento C/C++, incluindo o próprio GCC, a GNU C Library (cabeçalhos e binários, além de símbolos de depuração na saída @code{debug}), Binutils e um wrapper de vinculador."

msgid "The wrapper's purpose is to inspect the @code{-L} and @code{-l} switches passed to the linker, add corresponding @code{-rpath} arguments, and invoke the actual linker with this new set of arguments.  You can instruct the wrapper to refuse to link against libraries not in the store by setting the @env{GUIX_LD_WRAPPER_ALLOW_IMPURITIES} environment variable to @code{no}."
msgstr "O propósito do wrapper é inspecionar os switches @code{-L} e @code{-l} passados para o vinculador, adicionar argumentos @code{-rpath} correspondentes e invocar o vinculador real com esse novo conjunto de argumentos. Você pode instruir o wrapper a se recusar a vincular bibliotecas que não estejam no store definindo a variável de ambiente @env{GUIX_LD_WRAPPER_ALLOW_IMPURITIES} como @code{no}."

msgid "The package @code{gfortran-toolchain} provides a complete GCC toolchain for Fortran development.  For other languages, please use @samp{guix search gcc toolchain} (@pxref{guix-search,, Invoking guix package})."
msgstr "O pacote @code{gfortran-toolchain} fornece uma cadeia de ferramentas GCC completa para desenvolvimento Fortran. Para outras linguagens, use @samp{guix search gcc toolchain} (@pxref{guix-search,, Invoking guix package})."

msgid "Invoking @command{guix git authenticate}"
msgstr "Invocando @command{guix git authenticate}"

msgid "guix git authenticate"
msgstr "guix git authenticate"

msgid "The @command{guix git authenticate} command authenticates a Git checkout following the same rule as for channels (@pxref{channel-authentication, channel authentication}).  That is, starting from a given commit, it ensures that all subsequent commits are signed by an OpenPGP key whose fingerprint appears in the @file{.guix-authorizations} file of its parent commit(s)."
msgstr "O comando @command{guix git authenticate} autentica um checkout do Git seguindo a mesma regra dos canais (@pxref{channel-authentication, autenticação dos canais}). Ou seja, a partir de um commit determinado, ele garante que todos os commits subsequentes sejam assinados por uma chave OpenPGP cuja impressão digital apareça no arquivo @file{.guix-authorizations} de seus commits pais."

msgid "You will find this command useful if you maintain a channel.  But in fact, this authentication mechanism is useful in a broader context, so you might want to use it for Git repositories that have nothing to do with Guix."
msgstr "Você achará esse comando útil se mantiver um canal. Mas, na verdade, esse mecanismo de autenticação é útil em um contexto mais amplo, então você pode querer usá-lo para repositórios Git que não tenham nada a ver com Guix."

msgid "introduction, for Git authentication"
msgstr "introdução, para autenticação Git"

msgid "guix git authenticate [@var{options}@dots{}]\n"
msgstr "guix git authenticate [@var{opções}@dots{}]\n"

msgid "Should you have branches that require different introductions, you can specify them directly in @file{.git/config}.  For example, if the branch called @code{personal-fork} has a different introduction than other branches, you can extend @file{.git/config} along these lines:"
msgstr "Caso você tenha ramos que exijam introduções diferentes, você pode especificá-las diretamente em @file{.git/config}. Por exemplo, se o ramo chamado @code{personal-fork} tiver uma introdução diferente de outros ramos, você pode estender @file{.git/config} ao longo destas linhas:"

msgid ""
"[guix \"authentication-personal-fork\"]\n"
"\tintroduction-commit = cabba936fd807b096b48283debdcddccfea3900d\n"
"\tintroduction-signer = C0FF EECA BBA9 E6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\n"
"\tkeyring = keyring\n"
msgstr ""
"[guix \"authentication-personal-fork\"]\n"
"\tintroduction-commit = cabba936fd807b096b48283debdcddccfea3900d\n"
"\tintroduction-signer = C0FF EECA BBA9 E6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\n"
"\tkeyring = keyring\n"

msgid "The first run also attempts to install pre-push and post-merge hooks, such that @command{guix git authenticate} is invoked as soon as you run @command{git push}, @command{git pull}, and related commands; it does not overwrite preexisting hooks though."
msgstr "A primeira execução também tenta instalar ganchos pré-push e pós-mesclagem, de modo que @command{guix git authenticate} seja invocado assim que você executar @command{git push}, @command{git pull} e comandos relacionados; no entanto, ele não substitui ganchos preexistentes."

msgid "The command-line options described below allow you to fine-tune the process."
msgstr "As opções de linha de comando descritas abaixo permitem que você ajuste o processo."

msgid "--repository=@var{directory}"
msgstr "--repository=@var{diretório}"

msgid "-r @var{directory}"
msgstr "-r @var{diretório}"

msgid "Open the Git repository in @var{directory} instead of the current directory."
msgstr "Abra o repositório Git em @var{diretório} em vez do diretório atual."

msgid "--keyring=@var{reference}"
msgstr "--keyring=@var{referência}"

msgid "-k @var{reference}"
msgstr "-k @var{referência}"

msgid "Load OpenPGP keyring from @var{reference}, the reference of a branch such as @code{origin/keyring} or @code{my-keyring}.  The branch must contain OpenPGP public keys in @file{.key} files, either in binary form or ``ASCII-armored''.  By default the keyring is loaded from the branch named @code{keyring}."
msgstr "Carregue o chaveiro OpenPGP de @var{referência}, a referência de uma ramificação como @code{origin/keyring} ou @code{my-keyring}. A ramificação deve conter chaves públicas OpenPGP em arquivos @file{.key}, em formato binário ou ``ASCII-armored''. Por padrão, o chaveiro é carregado da ramificação chamada @code{keyring}."

msgid "--end=@var{commit}"
msgstr "--end=@var{commit}"

msgid "Authenticate revisions up to @var{commit}."
msgstr "Autentique revisões até @var{commit}."

msgid "Display commit signing statistics upon completion."
msgstr "Exibir estatísticas de assinatura de confirmação após a conclusão."

msgid "--cache-key=@var{key}"
msgstr "--cache-key=@var{chave}"

msgid "Previously-authenticated commits are cached in a file under @file{~/.cache/guix/authentication}.  This option forces the cache to be stored in file @var{key} in that directory."
msgstr "Os commits autenticados anteriormente são armazenados em cache em um arquivo em @file{~/.cache/guix/authentication}. Esta opção força o cache a ser armazenado no arquivo @var{chave} naquele diretório."

msgid "--historical-authorizations=@var{file}"
msgstr "--historical-authorizations=@var{arquivo}"

msgid "By default, any commit whose parent commit(s) lack the @file{.guix-authorizations} file is considered inauthentic.  In contrast, this option considers the authorizations in @var{file} for any commit that lacks @file{.guix-authorizations}.  The format of @var{file} is the same as that of @file{.guix-authorizations} (@pxref{channel-authorizations, @file{.guix-authorizations} format})."
msgstr "Por padrão, qualquer commit cujo(s) commit(s) pai(s) não tenha(m) o arquivo @file{.guix-authorizations} é considerado não autêntico. Em contraste, esta opção considera as autorizações em @var{arquivo} para qualquer commit que não tenha @file{.guix-authorizations}. O formato de @var{arquivo} é o mesmo que o de @file{.guix-authorizations} (@pxref{channel-authorizations, formato @file{.guix-authorizations}})."

msgid "GNU Guix provides several Scheme programming interfaces (APIs) to define, build, and query packages.  The first interface allows users to write high-level package definitions.  These definitions refer to familiar packaging concepts, such as the name and version of a package, its build system, and its dependencies.  These definitions can then be turned into concrete build actions."
msgstr "O GNU Guix fornece várias interfaces de programação Scheme (APIs) para definir, construir e consultar pacotes. A primeira interface permite que os usuários escrevam definições de pacotes de alto nível. Essas definições se referem a conceitos de empacotamento familiares, como o nome e a versão de um pacote, seu sistema de construção e suas dependências. Essas definições podem então ser transformadas em ações de construção concretas."

msgid "Build actions are performed by the Guix daemon, on behalf of users.  In a standard setup, the daemon has write access to the store---the @file{/gnu/store} directory---whereas users do not.  The recommended setup also has the daemon perform builds in chroots, under specific build users, to minimize interference with the rest of the system."
msgstr "As ações de build são executadas pelo daemon Guix, em nome dos usuários. Em uma configuração padrão, o daemon tem acesso de gravação ao armazém---o diretório @file{/gnu/store}---enquanto os usuários não têm. A configuração recomendada também faz com que o daemon execute builds em chroots, sob usuários de compilação específicos, para minimizar a interferência com o resto do sistema."

msgid "Lower-level APIs are available to interact with the daemon and the store.  To instruct the daemon to perform a build action, users actually provide it with a @dfn{derivation}.  A derivation is a low-level representation of the build actions to be taken, and the environment in which they should occur---derivations are to package definitions what assembly is to C programs.  The term ``derivation'' comes from the fact that build results @emph{derive} from them."
msgstr "APIs de nível inferior estão disponíveis para interagir com o daemon e o armazém. Para instruir o daemon a executar uma ação de compilação, os usuários na verdade fornecem a ele uma @dfn{derivação}. Uma derivação é uma representação de baixo nível das ações de compilação a serem tomadas e do ambiente no qual elas devem ocorrer --- derivações são para definições de pacotes o que assembly é para programas C. O termo ``derivação'' vem do fato de que os resultados de compilação @emph{derivam} deles."

msgid "This chapter describes all these APIs in turn, starting from high-level package definitions.  @xref{Source Tree Structure}, for a more general overview of the source code."
msgstr "Este capítulo descreve todas essas APIs, começando pelas definições de pacotes de alto nível. @xref{Source Tree Structure}, para uma visão geral mais geral do código-fonte."

msgid "From a programming viewpoint, the package definitions of the GNU distribution are provided by Guile modules in the @code{(gnu packages @dots{})} name space@footnote{Note that packages under the @code{(gnu packages @dots{})} module name space are not necessarily ``GNU packages''.  This module naming scheme follows the usual Guile module naming convention: @code{gnu} means that these modules are distributed as part of the GNU system, and @code{packages} identifies modules that define packages.} (@pxref{Modules, Guile modules,, guile, GNU Guile Reference Manual}).  For instance, the @code{(gnu packages emacs)} module exports a variable named @code{emacs}, which is bound to a @code{<package>} object (@pxref{Defining Packages})."
msgstr "Do ponto de vista da programação, as definições de pacotes da distribuição GNU são fornecidas pelos módulos Guile no namespace @code{(gnu packages @dots{})}@footnote{Observe que os pacotes sob o namespace do módulo @code{(gnu packages @dots{})} não são necessariamente ``pacotes GNU''. Este esquema de nomenclatura de módulos segue a convenção usual de nomenclatura de módulos Guile: @code{gnu} significa que esses módulos são distribuídos como parte do sistema GNU, e @code{packages} identifica módulos que definem pacotes.} (@pxref{Modules, módulos Guile,, guile, Manual de Referência do GNU Guile}). Por exemplo, o módulo @code{(gnu packages emacs)} exporta uma variável chamada @code{emacs}, que é vinculada a um objeto @code{<package>} (@pxref{Defining Packages})."

msgid "The @code{(gnu packages @dots{})} module name space is automatically scanned for packages by the command-line tools.  For instance, when running @code{guix install emacs}, all the @code{(gnu packages @dots{})} modules are scanned until one that exports a package object whose name is @code{emacs} is found.  This package search facility is implemented in the @code{(gnu packages)} module."
msgstr "O namespace do módulo @code{(gnu packages @dots{})} é automaticamente escaneado em busca de pacotes pelas ferramentas de linha de comando. Por exemplo, ao executar @code{guix install emacs}, todos os módulos @code{(gnu packages @dots{})} são escaneados até que um que exporte um objeto de pacote cujo nome é @code{emacs} seja encontrado. Esse recurso de busca de pacotes é implementado no módulo @code{(gnu packages)}."

msgid "package module search path"
msgstr "caminho de pesquisa dos módulos de pacote"

msgid "Users can store package definitions in modules with different names---e.g., @code{(my-packages emacs)}@footnote{Note that the file name and module name must match.  For instance, the @code{(my-packages emacs)} module must be stored in a @file{my-packages/emacs.scm} file relative to the load path specified with @option{--load-path} or @env{GUIX_PACKAGE_PATH}.  @xref{Modules and the File System,,, guile, GNU Guile Reference Manual}, for details.}.  There are two ways to make these package definitions visible to the user interfaces:"
msgstr "Os usuários podem armazenar definições de pacotes em módulos com nomes diferentes --- por exemplo, @code{(my-packages emacs)}@footnote{Observe que o nome do arquivo e o nome do módulo devem corresponder. Por exemplo, o módulo @code{(my-packages emacs)} deve ser armazenado em um arquivo @file{my-packages/emacs.scm} relativo ao caminho de carregamento especificado com @option{--load-path} ou @env{GUIX_PACKAGE_PATH}. @xref{Modules and the File System,,, guile, Manual de Referência do GNU Guile}, para detalhes.}. Há duas maneiras de tornar essas definições de pacotes visíveis para as interfaces do usuário:"

msgid "By adding the directory containing your package modules to the search path with the @code{-L} flag of @command{guix package} and other commands (@pxref{Common Build Options}), or by setting the @env{GUIX_PACKAGE_PATH} environment variable described below."
msgstr "Ao adicionar o diretório que contém os módulos do seu pacote ao caminho de pesquisa com o sinalizador @code{-L} do @command{guix package} e outros comandos (@pxref{Common Build Options}), ou definindo a variável de ambiente @env{GUIX_PACKAGE_PATH} descrita abaixo."

msgid "By defining a @dfn{channel} and configuring @command{guix pull} so that it pulls from it.  A channel is essentially a Git repository containing package modules.  @xref{Channels}, for more information on how to define and use channels."
msgstr "Ao definir um @dfn{canal} e configurando @command{guix pull} para que ele puxe dele. Um canal é essencialmente um repositório Git contendo módulos de pacote. @xref{Channels}, para mais informações sobre como definir e usar canais."

msgid "@env{GUIX_PACKAGE_PATH} works similarly to other search path variables:"
msgstr "@env{GUIX_PACKAGE_PATH} funciona de forma semelhante a outras variáveis de caminho de pesquisa:"

msgid "{Environment Variable} GUIX_PACKAGE_PATH"
msgstr "{Variável de ambiente} GUIX_PACKAGE_PATH"

msgid "This is a colon-separated list of directories to search for additional package modules.  Directories listed in this variable take precedence over the own modules of the distribution."
msgstr "Esta é uma lista de diretórios separados por dois pontos para procurar módulos de pacotes adicionais. Os diretórios listados nesta variável têm precedência sobre os próprios módulos da distribuição."

msgid "The distribution is fully @dfn{bootstrapped} and @dfn{self-contained}: each package is built based solely on other packages in the distribution.  The root of this dependency graph is a small set of @dfn{bootstrap binaries}, provided by the @code{(gnu packages bootstrap)} module.  For more information on bootstrapping, @pxref{Bootstrapping}."
msgstr "A distribuição é totalmente @dfn{bootstrapped} e @dfn{auto-contida}: cada pacote é construído com base somente em outros pacotes na distribuição. A raiz deste grafo de dependência é um pequeno conjunto dos @dfn{binários bootstrap}, fornecido pelo módulo @code{(gnu packages bootstrap)}. Para mais informações sobre bootstrapping, @pxref{Bootstrapping}."

msgid "The high-level interface to package definitions is implemented in the @code{(guix packages)} and @code{(guix build-system)} modules.  As an example, the package definition, or @dfn{recipe}, for the GNU Hello package looks like this:"
msgstr "A interface de alto nível para definições de pacotes é implementada nos módulos @code{(guix packages)} e @code{(guix build-system)}. Como exemplo, a definição de pacote, ou @dfn{receita}, para o pacote GNU Hello se parece com isto:"

msgid "Without being a Scheme expert, the reader may have guessed the meaning of the various fields here.  This expression binds the variable @code{hello} to a @code{<package>} record (@pxref{SRFI-9, Scheme records,, guile, GNU Guile Reference Manual}).  This package object can be inspected using procedures found in the @code{(guix packages)} module; for instance, @code{(package-name hello)} returns---surprise!---@code{\"hello\"}."
msgstr "Sem ser um especialista em Scheme, o leitor pode ter adivinhado o significado dos vários campos aqui. Esta expressão vincula a variável @code{hello} a um registro @code{<package>} (@pxref{SRFI-9, Scheme records,, guile, Manual de Referência do GNU Guile}). Este objeto de pacote pode ser inspecionado usando procedimentos encontrados no módulo @code{(guix packages)}; por exemplo, @code{(package-name hello)} retorna---surpresa!---@code{\"hello\"}."

msgid "In the example above, @code{hello} is defined in a module of its own, @code{(gnu packages hello)}.  Technically, this is not strictly necessary, but it is convenient to do so: all the packages defined in modules under @code{(gnu packages @dots{})} are automatically known to the command-line tools (@pxref{Package Modules})."
msgstr "No exemplo acima, @code{hello} é definido em um módulo próprio, @code{(gnu packages hello)}. Tecnicamente, isso não é estritamente necessário, mas é conveniente fazê-lo: todos os pacotes definidos em módulos sob @code{(gnu packages @dots{})} são automaticamente conhecidos pelas ferramentas de linha de comando (@pxref{Package Modules})."

msgid "There are a few points worth noting in the above package definition:"
msgstr "Há alguns pontos que vale a pena observar na definição do pacote acima:"

msgid "The @code{source} field of the package is an @code{<origin>} object (@pxref{origin Reference}, for the complete reference).  Here, the @code{url-fetch} method from @code{(guix download)} is used, meaning that the source is a file to be downloaded over FTP or HTTP."
msgstr "O campo @code{source} do pacote é um objeto @code{<origin>} (@pxref{origin Reference}, para a referência completa). Aqui, o método @code{url-fetch} de @code{(guix download)} é usado, o que significa que a fonte é um arquivo a ser baixado por FTP ou HTTP."

msgid "The @code{mirror://gnu} prefix instructs @code{url-fetch} to use one of the GNU mirrors defined in @code{(guix download)}."
msgstr "O prefixo @code{mirror://gnu} instrui @code{url-fetch} a usar um dos espelhos GNU definidos em @code{(guix download)}."

msgid "The @code{sha256} field specifies the expected SHA256 hash of the file being downloaded.  It is mandatory, and allows Guix to check the integrity of the file.  The @code{(base32 @dots{})} form introduces the base32 representation of the hash.  You can obtain this information with @code{guix download} (@pxref{Invoking guix download}) and @code{guix hash} (@pxref{Invoking guix hash})."
msgstr "O campo @code{sha256} especifica o hash SHA256 esperado do arquivo que está sendo baixado. É obrigatório e permite que o Guix verifique a integridade do arquivo. O formulário @code{(base32 @dots{})} introduz a representação base32 do hash. Você pode obter essas informações com @code{guix download} (@pxref{Invoking guix download}) e @code{guix hash} (@pxref{Invoking guix hash})."

msgid "patches"
msgstr "remendos"

msgid "When needed, the @code{origin} form can also have a @code{patches} field listing patches to be applied, and a @code{snippet} field giving a Scheme expression to modify the source code."
msgstr "Quando necessário, o formulário @code{origin} também pode ter um campo @code{patches} listando os remendos a serem aplicados e um campo @code{snippet} fornecendo uma expressão Scheme para modificar o código-fonte."

msgid "GNU Build System"
msgstr "Sistema de construção GNU"

msgid "The @code{build-system} field specifies the procedure to build the package (@pxref{Build Systems}).  Here, @code{gnu-build-system} represents the familiar GNU Build System, where packages may be configured, built, and installed with the usual @code{./configure && make && make check && make install} command sequence."
msgstr "O campo @code{build-system} especifica o procedimento para construir o pacote (@pxref{Build Systems}). Aqui, @code{gnu-build-system} representa o familiar GNU Build System, onde os pacotes podem ser configurados, construídos e instalados com a sequência de comando usual @code{./configure && make && make check && make install}."

msgid "When you start packaging non-trivial software, you may need tools to manipulate those build phases, manipulate files, and so on.  @xref{Build Utilities}, for more on this."
msgstr "Ao começar a empacotar software não trivial, você pode precisar de ferramentas para manipular essas fases de compilação, manipular arquivos e assim por diante. @xref{Build Utilities}, para mais informações sobre isso."

msgid "The @code{arguments} field specifies options for the build system (@pxref{Build Systems}).  Here it is interpreted by @code{gnu-build-system} as a request run @file{configure} with the @option{--enable-silent-rules} flag."
msgstr "O campo @code{arguments} especifica opções para o sistema de compilação (@pxref{Build Systems}). Aqui, ele é interpretado por @code{gnu-build-system} como uma solicitação executada @file{configure} com o sinalizador @option{--enable-silent-rules}."

msgid "The value of the @code{arguments} field is a list of arguments passed to the build system and that end up being applied, as with @code{apply} (@pxref{Fly Evaluation, @code{apply},, guile, GNU Guile Reference Manual})."
msgstr "O valor do campo @code{arguments} é uma lista de argumentos passados para o sistema de construção mais adiante, como com @code{apply} (@pxref{Fly Evaluation, @code{apply},, guile, Manual de referência do GNU Guile})."

msgid "The hash-colon (@code{#:}) sequence defines a Scheme @dfn{keyword} (@pxref{Keywords,,, guile, GNU Guile Reference Manual}), and @code{#:configure-flags} is a keyword used to pass a keyword argument to the build system (@pxref{Coding With Keywords,,, guile, GNU Guile Reference Manual})."
msgstr "A sequência hash-dois-pontos (@code{#:}) define um @dfn{palavra-chave} em Scheme (@pxref{Keywords,,, guile, Manual de referência do GNU Guile}) e @code{#:configure-flags} é uma palavra-chave usada para passar um argumento de palavra-chave para o sistema de compilação (@pxref{Coding With Keywords,,, guile, Manual de referência do GNU Guile})."

msgid "#~"
msgstr "#~"

msgid "gexp"
msgstr "gexp"

msgid "The @code{inputs} field specifies inputs to the build process---i.e., build-time or run-time dependencies of the package.  Here, we add an input, a reference to the @code{gawk} variable; @code{gawk} is itself bound to a @code{<package>} object."
msgstr "O campo @code{inputs} especifica entradas para o processo de construção---i.e., dependências de tempo de construção ou tempo de execução do pacote. Aqui, adicionamos uma entrada, uma referência à variável @code{gawk}; @code{gawk} é ele próprio vinculado a um objeto @code{<package>}."

msgid "Note that GCC, Coreutils, Bash, and other essential tools do not need to be specified as inputs here.  Instead, @code{gnu-build-system} takes care of ensuring that they are present (@pxref{Build Systems})."
msgstr "Note que GCC, Coreutils, Bash e outras ferramentas essenciais não precisam ser especificadas como entradas aqui. Em vez disso, @code{gnu-build-system} cuida de garantir que elas estejam presentes (@pxref{Build Systems})."

msgid "However, any other dependencies need to be specified in the @code{inputs} field.  Any dependency not specified here will simply be unavailable to the build process, possibly leading to a build failure."
msgstr "No entanto, quaisquer outras dependências precisam ser especificadas no campo @code{inputs}. Qualquer dependência não especificada aqui simplesmente ficará indisponível para o processo de build, possivelmente levando a uma falha de build."

msgid "@xref{package Reference}, for a full description of possible fields."
msgstr "@xref{package Reference}, para uma descrição completa dos campos possíveis."

msgid "Scheme programming language, getting started"
msgstr "Linguagem de programação Scheme, primeiros passos"

msgid "Intimidated by the Scheme language or curious about it? The Cookbook has a short section to get started that recaps some of the things shown above and explains the fundamentals.  @xref{A Scheme Crash Course,,, guix-cookbook, GNU Guix Cookbook}, for more information."
msgstr "Intimidado pela linguagem Scheme ou curioso sobre ela? O Livro de receitas tem uma seção curta para começar que recapitula algumas das coisas mostradas acima e explica os fundamentos. @xref{Um curso intensivo de Scheme,,, guix-cookbook.pt_BR, Livro de receitas do GNU Guix}, para mais informações."

msgid "Once a package definition is in place, the package may actually be built using the @code{guix build} command-line tool (@pxref{Invoking guix build}), troubleshooting any build failures you encounter (@pxref{Debugging Build Failures}).  You can easily jump back to the package definition using the @command{guix edit} command (@pxref{Invoking guix edit}).  @xref{Packaging Guidelines}, for more information on how to test package definitions, and @ref{Invoking guix lint}, for information on how to check a definition for style conformance."
msgstr "Uma vez que uma definição de pacote esteja pronta, o pacote pode ser realmente construído usando a ferramenta de linha de comando @code{guix build} (@pxref{Invoking guix build}), solucionando problemas de quaisquer falhas de construção que você encontrar (@pxref{Debugging Build Failures}). Você pode facilmente voltar para a definição do pacote usando o comando @command{guix edit} (@pxref{Invoking guix edit}). @xref{Packaging Guidelines}, para mais informações sobre como testar definições de pacote, e @ref{Invoking guix lint}, para informações sobre como verificar uma definição para conformidade de estilo."

msgid "GUIX_PACKAGE_PATH"
msgstr "GUIX_PACKAGE_PATH"

msgid "Lastly, @pxref{Channels}, for information on how to extend the distribution by adding your own package definitions in a ``channel''."
msgstr "Por fim, @pxref{Channels}, para obter informações sobre como estender a distribuição adicionando suas próprias definições de pacote em um ``canal''."

msgid "Finally, updating the package definition to a new upstream version can be partly automated by the @command{guix refresh} command (@pxref{Invoking guix refresh})."
msgstr "Por fim, a atualização da definição do pacote para uma nova versão upstream pode ser parcialmente automatizada pelo comando @command{guix refresh} (@pxref{Invoking guix refresh})."

msgid "Behind the scenes, a derivation corresponding to the @code{<package>} object is first computed by the @code{package-derivation} procedure.  That derivation is stored in a @file{.drv} file under @file{/gnu/store}.  The build actions it prescribes may then be realized by using the @code{build-derivations} procedure (@pxref{The Store})."
msgstr "Nos bastidores, uma derivação correspondente ao objeto @code{<package>} é primeiro computada pelo procedimento @code{package-derivation}. Essa derivação é armazenada em um arquivo @file{.drv} em @file{/gnu/store}. As ações de construção que ele prescreve podem então ser realizadas usando o procedimento @code{build-derivations} (@pxref{The Store})."

msgid "{Procedure} package-derivation store package [system]"
msgstr "{Procedimento} package-derivation armazém pacote [sistema]"

msgid "Return the @code{<derivation>} object of @var{package} for @var{system} (@pxref{Derivations})."
msgstr "Retorne o objeto @code{<derivation>} de @var{pacote} para @var{sistema} (@pxref{Derivations})."

msgid "@var{package} must be a valid @code{<package>} object, and @var{system} must be a string denoting the target system type---e.g., @code{\"x86_64-linux\"} for an x86_64 Linux-based GNU system.  @var{store} must be a connection to the daemon, which operates on the store (@pxref{The Store})."
msgstr "@var{pacote} deve ser um objeto @code{<package>} válido e @var{sistema} deve ser uma string que indique o tipo de sistema de destino — por exemplo, @code{\"x86_64-linux\"} para um sistema GNU baseado em Linux x86_64. @var{armazém} deve ser uma conexão com o daemon, que opera no armazém (@pxref{The Store})."

msgid "Similarly, it is possible to compute a derivation that cross-builds a package for some other system:"
msgstr "Da mesma forma, é possível calcular uma derivação que crie um pacote para algum outro sistema:"

msgid "{Procedure} package-cross-derivation store package target [system]"
msgstr "{Procedimento} package-cross-derivation armazém pacote alvo [sistema]"

msgid "Return the @code{<derivation>} object of @var{package} cross-built from @var{system} to @var{target}."
msgstr "Retorne o objeto @code{<derivation>} de @var{pacote} criado de @var{sistema} para @var{alvo}."

msgid "@var{target} must be a valid GNU triplet denoting the target hardware and operating system, such as @code{\"aarch64-linux-gnu\"} (@pxref{Specifying Target Triplets,,, autoconf, Autoconf})."
msgstr "@var{alvo} deve ser um tripleto GNU válido que indique o hardware e o sistema operacional de destino, como @code{\"aarch64-linux-gnu\"} (@pxref{Specifying Target Triplets,,, autoconf, Autoconf})."

msgid "Once you have package definitions, you can easily define @emph{variants} of those packages.  @xref{Defining Package Variants}, for more on that."
msgstr "Depois de ter as definições dos pacotes, você pode definir facilmente @emph{variantes} desses pacotes. @xref{Defining Package Variants}, para mais informações sobre isso."

msgid "@code{package} Reference"
msgstr "Referência do @code{package}"

msgid "This section summarizes all the options available in @code{package} declarations (@pxref{Defining Packages})."
msgstr "Esta seção resume todas as opções disponíveis nas declarações @code{package} (@pxref{Defining Packages})."

msgid "{Data Type} package"
msgstr "{Tipo de dados} package"

msgid "This is the data type representing a package recipe."
msgstr "Este é o tipo de dado que representa uma receita de pacote."

msgid "version"
msgstr "version"

msgid "source"
msgstr "source"

msgid "An object telling how the source code for the package should be acquired.  Most of the time, this is an @code{origin} object, which denotes a file fetched from the Internet (@pxref{origin Reference}).  It can also be any other ``file-like'' object such as a @code{local-file}, which denotes a file from the local file system (@pxref{G-Expressions, @code{local-file}})."
msgstr "Um objeto que diz como o código-fonte do pacote deve ser adquirido. Na maioria das vezes, este é um objeto @code{origin}, que denota um arquivo obtido da Internet (@pxref{origin Reference}). Também pode ser qualquer outro objeto ``tipo arquivo'', como um @code{local-file}, que denota um arquivo do sistema de arquivos local (@pxref{G-Expressions, @code{local-file}})."

msgid "build-system"
msgstr "build-system"

msgid "The build system that should be used to build the package (@pxref{Build Systems})."
msgstr "O sistema de compilação que deve ser usado para compilar o pacote (@pxref{Build Systems})."

msgid "@code{arguments} (default: @code{'()})"
msgstr "@code{arguments} (padrão: @code{'()})"

msgid "The arguments that should be passed to the build system (@pxref{Build Systems}).  This is a list, typically containing sequential keyword-value pairs, as in this example:"
msgstr "Os argumentos que devem ser passados para o sistema de compilação (@pxref{Build Systems}). Esta é uma lista, normalmente contendo pares sequenciais de palavra-chave-valor, como neste exemplo:"

msgid "The exact set of supported keywords depends on the build system (@pxref{Build Systems}), but you will find that almost all of them honor @code{#:configure-flags}, @code{#:make-flags}, @code{#:tests?}, and @code{#:phases}.  The @code{#:phases} keyword in particular lets you modify the set of build phases for your package (@pxref{Build Phases})."
msgstr "O conjunto exato de palavras-chave suportadas depende do sistema de compilação (@pxref{Build Systems}), mas você verá que quase todas elas honram @code{#:configure-flags}, @code{#:make-flags}, @code{#:tests?} e @code{#:phases}. A palavra-chave @code{#:phases} em particular permite que você modifique o conjunto de fases de compilação para seu pacote (@pxref{Build Phases})."

msgid "The REPL has dedicated commands to interactively inspect values of some of these arguments, as a convenient debugging aid (@pxref{Using Guix Interactively})."
msgstr "O REPL tem comandos dedicados para inspecionar interativamente os valores de alguns desses argumentos, como um auxílio de depuração conveniente (@pxref{Using Guix Interactively})."

msgid "Compatibility Note"
msgstr "Nota de compatibilidade"

msgid "Until version 1.3.0, the @code{arguments} field would typically use @code{quote} (@code{'}) or @code{quasiquote} (@code{`}) and no G-expressions, like so:"
msgstr "Até a versão 1.3.0, o campo @code{arguments} normalmente usaria @code{quote} (@code{'}) ou @code{quasiquote} (@code{`}) e nenhuma expressão G, assim:"

msgid "To convert from that style to the one shown above, you can run @code{guix style -S arguments @var{package}} (@pxref{Invoking guix style})."
msgstr "Para converter esse estilo para o mostrado acima, você pode executar @code{guix style -S arguments @var{pacote}} (@pxref{Invoking guix style})."

msgid "@code{inputs} (default: @code{'()})"
msgstr "@code{inputs} (padrão: @code{'()})"

msgid "@code{native-inputs} (default: @code{'()})"
msgstr "@code{native-inputs} (padrão: @code{'()})"

msgid "@code{propagated-inputs} (default: @code{'()})"
msgstr "@code{propagated-inputs} (padrão: @code{'()})"

msgid "inputs, of packages"
msgstr "entradas, de pacotes"

msgid "These fields list dependencies of the package.  Each element of these lists is either a package, origin, or other ``file-like object'' (@pxref{G-Expressions}); to specify the output of that file-like object that should be used, pass a two-element list where the second element is the output (@pxref{Packages with Multiple Outputs}, for more on package outputs).  For example, the list below specifies three inputs:"
msgstr "Esses campos listam dependências do pacote. Cada elemento dessas listas é um pacote, origem ou outro ``objeto tipo arquivo'' (@pxref{G-Expressions}); para especificar a saída desse objeto tipo arquivo que deve ser usado, passe uma lista de dois elementos onde o segundo elemento é a saída (@pxref{Packages with Multiple Outputs}, para mais informações sobre saídas de pacotes). Por exemplo, a lista abaixo especifica três entradas:"

msgid ""
"(list libffi libunistring\n"
"      `(,glib \"bin\"))      ;the \"bin\" output of GLib\n"
msgstr ""
"(list libffi libunistring\n"
"      `(,glib \"bin\"))      ;a saída \"bin\" de GLib\n"

msgid "In the example above, the @code{\"out\"} output of @code{libffi} and @code{libunistring} is used."
msgstr "No exemplo acima, a saída @code{\"out\"} de @code{libffi} e @code{libunistring} é usada."

msgid "Until version 1.3.0, input lists were a list of tuples, where each tuple has a label for the input (a string) as its first element, a package, origin, or derivation as its second element, and optionally the name of the output thereof that should be used, which defaults to @code{\"out\"}.  For example, the list below is equivalent to the one above, but using the @dfn{old input style}:"
msgstr "Até a versão 1.3.0, as listas de entrada eram uma lista de tuplas, onde cada tupla tem um rótulo para a entrada (uma string) como seu primeiro elemento, um pacote, origem ou derivação como seu segundo elemento e, opcionalmente, o nome da saída que deve ser usada, cujo padrão é @code{\"out\"}. Por exemplo, a lista abaixo é equivalente à acima, mas usando o @dfn{antigo estilo de entrada}:"

msgid ""
";; Old input style (deprecated).\n"
"`((\"libffi\" ,libffi)\n"
"  (\"libunistring\" ,libunistring)\n"
"  (\"glib:bin\" ,glib \"bin\"))  ;the \"bin\" output of GLib\n"
msgstr ""
";; Estilo de entrada antigo (obsoleto).\n"
"`((\"libffi\" ,libffi)\n"
"  (\"libunistring\" ,libunistring)\n"
"  (\"glib:bin\" ,glib \"bin\"))  ;a saída \"bin\" do GLib\n"

msgid "This style is now deprecated; it is still supported but support will be removed in a future version.  It should not be used for new package definitions.  @xref{Invoking guix style}, on how to migrate to the new style."
msgstr "Este estilo agora está obsoleto; ele ainda é suportado, mas o suporte será removido em uma versão futura. Ele não deve ser usado para novas definições de pacote. @xref{Invoking guix style}, sobre como migrar para o novo estilo."

msgid "cross compilation, package dependencies"
msgstr "compilação cruzada, dependências de pacotes"

msgid "The distinction between @code{native-inputs} and @code{inputs} is necessary when considering cross-compilation.  When cross-compiling, dependencies listed in @code{inputs} are built for the @emph{target} architecture; conversely, dependencies listed in @code{native-inputs} are built for the architecture of the @emph{build} machine."
msgstr "A distinção entre @code{native-inputs} e @code{inputs} é necessária ao considerar a compilação cruzada. Ao compilar cruzadamente, as dependências listadas em @code{inputs} são construídas para a arquitetura @emph{target} (alvo); inversamente, as dependências listadas em @code{native-inputs} são construídas para a arquitetura da máquina @emph{build}."

msgid "@code{native-inputs} is typically used to list tools needed at build time, but not at run time, such as Autoconf, Automake, pkg-config, Gettext, or Bison.  @command{guix lint} can report likely mistakes in this area (@pxref{Invoking guix lint})."
msgstr "@code{native-inputs} é normalmente usado para listar ferramentas necessárias no momento da compilação, mas não no momento da execução, como Autoconf, Automake, pkg-config, Gettext ou Bison. @command{guix lint} pode relatar prováveis erros nesta área (@pxref{Invoking guix lint})."

msgid "package-propagated-inputs"
msgstr "package-propagated-inputs"

msgid "Lastly, @code{propagated-inputs} is similar to @code{inputs}, but the specified packages will be automatically installed to profiles (@pxref{Features, the role of profiles in Guix}) alongside the package they belong to (@pxref{package-cmd-propagated-inputs, @command{guix package}}, for information on how @command{guix package} deals with propagated inputs)."
msgstr "Por fim, @code{propagated-inputs} é semelhante a @code{inputs}, mas os pacotes especificados serão instalados automaticamente nos perfis (@pxref{Features, a função dos perfis no Guix}) junto com o pacote ao qual pertencem (@pxref{package-cmd-propagated-inputs, @command{guix package}}, para obter informações sobre como @command{guix package} lida com entradas propagadas)."

msgid "For example this is necessary when packaging a C/C++ library that needs headers of another library to compile, or when a pkg-config file refers to another one @i{via} its @code{Requires} field."
msgstr "Por exemplo, isso é necessário ao empacotar uma biblioteca C/C++ que precisa de cabeçalhos de outra biblioteca para compilar, ou quando um arquivo pkg-config faz referência a outro por meio de seu campo @code{Requires}."

msgid "Another example where @code{propagated-inputs} is useful is for languages that lack a facility to record the run-time search path akin to the @code{RUNPATH} of ELF files; this includes Guile, Python, Perl, and more.  When packaging libraries written in those languages, ensure they can find library code they depend on at run time by listing run-time dependencies in @code{propagated-inputs} rather than @code{inputs}."
msgstr "Outro exemplo em que @code{propagated-inputs} é útil é para linguagens que não têm um recurso para registrar o caminho de pesquisa em tempo de execução semelhante ao @code{RUNPATH} de arquivos ELF; isso inclui Guile, Python, Perl e mais. Ao empacotar bibliotecas escritas nessas linguagens, garanta que elas possam encontrar o código da biblioteca do qual dependem em tempo de execução listando as dependências em tempo de execução em @code{propagated-inputs} em vez de @code{inputs}."

msgid "@code{outputs} (default: @code{'(\"out\")})"
msgstr "@code{outputs} (padrão: @code{'(\"out\")})"

msgid "The list of output names of the package.  @xref{Packages with Multiple Outputs}, for typical uses of additional outputs."
msgstr "A lista de nomes de saída do pacote. @xref{Packages with Multiple Outputs}, para usos típicos de saídas adicionais."

msgid "@code{native-search-paths} (default: @code{'()})"
msgstr "@code{native-search-paths} (padrão: @code{'()})"

msgid "@code{search-paths} (default: @code{'()})"
msgstr "@code{search-paths} (padrão: @code{'()})"

msgid "A list of @code{search-path-specification} objects describing search-path environment variables honored by the package.  @xref{Search Paths}, for more on search path specifications."
msgstr "Uma lista de objetos @code{search-path-specification} descrevendo variáveis de ambiente do caminho de pesquisa respeitadas pelo pacote. @xref{Search Paths}, para mais informações sobre especificações do caminho de pesquisa."

msgid "As for inputs, the distinction between @code{native-search-paths} and @code{search-paths} only matters when cross-compiling.  In a cross-compilation context, @code{native-search-paths} applies exclusively to native inputs whereas @code{search-paths} applies only to host inputs."
msgstr "Quanto às entradas, a distinção entre @code{native-search-paths} e @code{search-paths} só importa quando há compilação cruzada. Em um contexto de compilação cruzada, @code{native-search-paths} se aplica exclusivamente a entradas nativas, enquanto @code{search-paths} se aplica somente a entradas de host."

msgid "Packages such as cross-compilers care about target inputs---for instance, our (modified) GCC cross-compiler has @env{CROSS_C_INCLUDE_PATH} in @code{search-paths}, which allows it to pick @file{.h} files for the target system and @emph{not} those of native inputs.  For the majority of packages though, only @code{native-search-paths} makes sense."
msgstr "Pacotes como compiladores cruzados se importam com entradas de destino --- por exemplo, nosso compilador cruzado GCC (modificado) tem @env{CROSS_C_INCLUDE_PATH} em @code{search-paths}, o que permite que ele escolha arquivos @file{.h} para o sistema de destino e @emph{não} aqueles de entradas nativas. Para a maioria dos pacotes, porém, apenas @code{native-search-paths} faz sentido."

msgid "@code{replacement} (default: @code{#f})"
msgstr "@code{replacement} (padrão: @code{#f})"

msgid "This must be either @code{#f} or a package object that will be used as a @dfn{replacement} for this package.  @xref{Security Updates, grafts}, for details."
msgstr "Deve ser @code{#f} ou um objeto de pacote que será usado como um @dfn{substituição} para este pacote. @xref{Security Updates, enxertos}, para detalhes."

msgid "synopsis"
msgstr "synopsis"

msgid "A one-line description of the package."
msgstr "Uma descrição de uma linha do pacote."

msgid "description"
msgstr "description"

msgid "A more elaborate description of the package, as a string in Texinfo syntax."
msgstr "Uma descrição mais elaborada do pacote, como uma string na sintaxe Texinfo."

msgid "license"
msgstr "license"

msgid "license, of packages"
msgstr "licença, de pacotes"

msgid "The license of the package; a value from @code{(guix licenses)}, or a list of such values."
msgstr "A licença do pacote; um valor de @code{(guix licenses)}, ou uma lista de tais valores."

msgid "home-page"
msgstr "home-page"

msgid "The URL to the home-page of the package, as a string."
msgstr "A URL para a página inicial do pacote, como uma string."

msgid "@code{supported-systems} (default: @code{%supported-systems})"
msgstr "@code{supported-systems} (padrão: @code{%supported-systems})"

msgid "The list of systems supported by the package, as strings of the form @code{architecture-kernel}, for example @code{\"x86_64-linux\"}."
msgstr "A lista de sistemas suportados pelo pacote, como strings do formato @code{arquitetura-kernel}, por exemplo @code{\"x86_64-linux\"}."

msgid "@code{location} (default: source location of the @code{package} form)"
msgstr "@code{location} (padrão: localização de origem do formulário @code{package})"

msgid "The source location of the package.  It is useful to override this when inheriting from another package, in which case this field is not automatically corrected."
msgstr "O local de origem do pacote. É útil sobrescrever isso ao herdar de outro pacote, em cujo caso esse campo não é corrigido automaticamente."

msgid "this-package"
msgstr "this-package"

msgid "When used in the @emph{lexical scope} of a package field definition, this identifier resolves to the package being defined."
msgstr "Quando usado no @emph{escopo lexical} de uma definição de campo de pacote, esse identificador é resolvido para o pacote que está sendo definido."

msgid "The example below shows how to add a package as a native input of itself when cross-compiling:"
msgstr "O exemplo abaixo mostra como adicionar um pacote como uma entrada nativa de si mesmo durante a compilação cruzada:"

msgid ""
"(package\n"
"  (name \"guile\")\n"
"  ;; ...\n"
"\n"
msgstr ""
"(package\n"
"  (name \"guile\")\n"
"  ;; ...\n"
"\n"

msgid ""
"  ;; When cross-compiled, Guile, for example, depends on\n"
"  ;; a native version of itself.  Add it here.\n"
"  (native-inputs (if (%current-target-system)\n"
"                     (list this-package)\n"
"                     '())))\n"
msgstr ""
"  ;; Quando compilado de forma cruzada, Guile, por exemplo, depende de\n"
"  ;; uma versão nativa de si mesmo. Adicione aqui.\n"
"  (native-inputs (if (%current-target-system)\n"
"                     (list this-package)\n"
"                     '())))\n"

msgid "It is an error to refer to @code{this-package} outside a package definition."
msgstr "É um erro fazer referência a @code{this-package} fora de uma definição de pacote."

msgid "The following helper procedures are provided to help deal with package inputs."
msgstr "Os seguintes procedimentos auxiliares são fornecidos para ajudar a lidar com entradas de pacotes."

msgid "{Procedure} lookup-package-input package name"
msgstr "{Procedimento} lookup-package-input pacote nome"

msgid "{Procedure} lookup-package-native-input package name"
msgstr "{Procedimento} lookup-package-native-input pacote nome"

msgid "{Procedure} lookup-package-propagated-input package name"
msgstr "{Procedimento} lookup-package-propagated-input pacote nome"

msgid "{Procedure} lookup-package-direct-input package name"
msgstr "{Procedimento} lookup-package-direct-input pacote nome"

msgid "Look up @var{name} among @var{package}'s inputs (or native, propagated, or direct inputs).  Return it if found, @code{#f} otherwise."
msgstr "Procure @var{nome} entre as entradas de @var{pacote} (ou entradas nativas, propagadas ou diretas). Retorne-o se encontrado, @code{#f} caso contrário."

msgid ""
"(use-modules (guix packages) (gnu packages base))\n"
"\n"
msgstr ""
"(use-modules (guix packages) (gnu packages base))\n"
"\n"

msgid ""
"(lookup-package-direct-input coreutils \"gmp\")\n"
"@result{} #<package gmp@@6.2.1 @dots{}>\n"
msgstr ""
"(lookup-package-direct-input coreutils \"gmp\")\n"
"@result{} #<package gmp@@6.2.1 @dots{}>\n"

msgid "In this example we obtain the @code{gmp} package that is among the direct inputs of @code{coreutils}."
msgstr "Neste exemplo, obtemos o pacote @code{gmp} que está entre as entradas diretas de @code{coreutils}."

msgid "Sometimes you will want to obtain the list of inputs needed to @emph{develop} a package---all the inputs that are visible when the package is compiled.  This is what the @code{package-development-inputs} procedure returns."
msgstr "Às vezes, você vai querer obter a lista de entradas necessárias para @emph{desenvolver} um pacote---todas as entradas que são visíveis quando o pacote é compilado. É isso que o procedimento @code{package-development-inputs} retorna."

msgid "{Procedure} package-development-inputs package [system] [#:target #f]"
msgstr "{Procedimento} package-development-inputs pacote [sistema] [#:target #f]"

msgid "Return the list of inputs required by @var{package} for development purposes on @var{system}.  When @var{target} is true, return the inputs needed to cross-compile @var{package} from @var{system} to @var{target}, where @var{target} is a triplet such as @code{\"aarch64-linux-gnu\"}."
msgstr "Retorna a lista de entradas necessárias para @var{pacote} para fins de desenvolvimento em @var{sistema}. Quando @var{target} é verdadeiro, retorna as entradas necessárias para compilar cruzadamente @var{pacote} de @var{sistema} para o alvo @var{target}, onde @var{target} é um tripleto como @code{\"aarch64-linux-gnu\"}."

msgid "Note that the result includes both explicit inputs and implicit inputs---inputs automatically added by the build system (@pxref{Build Systems}).  Let us take the @code{hello} package to illustrate that:"
msgstr "Note que o resultado inclui entradas explícitas e entradas implícitas---entradas adicionadas automaticamente pelo sistema de construção (@pxref{Build Systems}). Vamos pegar o pacote @code{hello} para ilustrar isso:"

msgid ""
"(use-modules (gnu packages base) (guix packages))\n"
"\n"
msgstr ""
"(use-modules (gnu packages base) (guix packages))\n"
"\n"

msgid ""
"hello\n"
"@result{} #<package hello@@2.10 gnu/packages/base.scm:79 7f585d4f6790>\n"
"\n"
msgstr ""
"hello\n"
"@result{} #<package hello@@2.10 gnu/packages/base.scm:79 7f585d4f6790>\n"
"\n"

msgid ""
"(package-direct-inputs hello)\n"
"@result{} ()\n"
"\n"
msgstr ""
"(package-direct-inputs hello)\n"
"@result{} ()\n"
"\n"

msgid ""
"(package-development-inputs hello)\n"
"@result{} ((\"source\" @dots{}) (\"tar\" #<package tar@@1.32 @dots{}>) @dots{})\n"
msgstr ""
"(package-development-inputs hello)\n"
"@result{} ((\"source\" @dots{}) (\"tar\" #<package tar@@1.32 @dots{}>) @dots{})\n"

msgid "In this example, @code{package-direct-inputs} returns the empty list, because @code{hello} has zero explicit dependencies.  Conversely, @code{package-development-inputs} includes inputs implicitly added by @code{gnu-build-system} that are required to build @code{hello}: tar, gzip, GCC, libc, Bash, and more.  To visualize it, @command{guix graph hello} would show you explicit inputs, whereas @command{guix graph -t bag hello} would include implicit inputs (@pxref{Invoking guix graph})."
msgstr "Neste exemplo, @code{package-direct-inputs} retorna a lista vazia, porque @code{hello} tem zero dependências explícitas. Por outro lado, @code{package-development-inputs} inclui entradas adicionadas implicitamente por @code{gnu-build-system} que são necessárias para construir @code{hello}: tar, gzip, GCC, libc, Bash e mais. Para visualizá-lo, @command{guix graph hello} mostraria entradas explícitas, enquanto @command{guix graph -t bag hello} incluiria entradas implícitas (@pxref{Invoking guix graph})."

msgid "Because packages are regular Scheme objects that capture a complete dependency graph and associated build procedures, it is often useful to write procedures that take a package and return a modified version thereof according to some parameters.  Below are a few examples."
msgstr "Como os pacotes são objetos Scheme regulares que capturam um grafo de dependência completo e procedimentos de construção associados, geralmente é útil escrever procedimentos que pegam um pacote e retornam uma versão modificada dele de acordo com alguns parâmetros. Abaixo estão alguns exemplos."

msgid "tool chain, choosing a package's tool chain"
msgstr "cadeia de ferramentas, escolhendo a cadeia de ferramentas de um pacote"

msgid "{Procedure} package-with-c-toolchain package toolchain"
msgstr "{Procedimento} package-with-c-toolchain pacote cadeia"

msgid "Return a variant of @var{package} that uses @var{toolchain} instead of the default GNU C/C++ toolchain.  @var{toolchain} must be a list of inputs (label/package tuples) providing equivalent functionality, such as the @code{gcc-toolchain} package."
msgstr "Retorna uma variante de @var{pacote} que usa @var{cadeia} de ferramentas em vez da cadeia de ferramentas padrão GNU C/C++. @var{cadeia} deve ser uma lista de entradas (tuplas de rótulo/pacote) que fornecem funcionalidade equivalente, como o pacote @code{gcc-toolchain}."

msgid "The example below returns a variant of the @code{hello} package built with GCC@tie{}10.x and the rest of the GNU tool chain (Binutils and the GNU C Library) instead of the default tool chain:"
msgstr "O exemplo abaixo retorna uma variante do pacote @code{hello} criado com GCC@tie{}10.x e o restante da cadeia de ferramentas GNU (Binutils e a Biblioteca C GNU) em vez da cadeia de ferramentas padrão:"

msgid ""
"(let ((toolchain (specification->package \"gcc-toolchain@@10\")))\n"
"  (package-with-c-toolchain hello `((\"toolchain\" ,toolchain))))\n"
msgstr ""
"(let ((toolchain (specification->package \"gcc-toolchain@@10\")))\n"
"  (package-with-c-toolchain hello `((\"toolchain\" ,toolchain))))\n"

msgid "The build tool chain is part of the @dfn{implicit inputs} of packages---it's usually not listed as part of the various ``inputs'' fields and is instead pulled in by the build system.  Consequently, this procedure works by changing the build system of @var{package} so that it pulls in @var{toolchain} instead of the defaults.  @xref{Build Systems}, for more on build systems."
msgstr "A cadeia de ferramentas de construção é parte das @dfn{entradas implícitas} dos pacotes---geralmente não é listada como parte dos vários campos ``entradas'' e, em vez disso, é puxada pelo sistema de construção. Consequentemente, esse procedimento funciona alterando o sistema de construção de @var{pacote} para que ele puxe @var{cadeia} de ferramentas em vez dos padrões. @xref{Build Systems}, para mais informações sobre sistemas de construção."

msgid "@code{origin} Reference"
msgstr "Referência do @code{origin}"

msgid "This section documents @dfn{origins}.  An @code{origin} declaration specifies data that must be ``produced''---downloaded, usually---and whose content hash is known in advance.  Origins are primarily used to represent the source code of packages (@pxref{Defining Packages}).  For that reason, the @code{origin} form allows you to declare patches to apply to the original source code as well as code snippets to modify it."
msgstr "Esta seção documenta @dfn{origens}. Uma declaração @code{origin} especifica dados que devem ser ``produzidos''---baixados, normalmente---e cujo hash de conteúdo é conhecido com antecedência. Origens são usados principalmente para representar o código-fonte de pacotes (@pxref{Defining Packages}). Por esse motivo, o formulário @code{origin} permite que você declare remendos para aplicar ao código-fonte original, bem como trechos de código para modificá-lo."

msgid "{Data Type} origin"
msgstr "{Tipo de dados} origin"

msgid "This is the data type representing a source code origin."
msgstr "Este é o tipo de dado que representa a origem do código-fonte."

msgid "uri"
msgstr "uri"

msgid "An object containing the URI of the source.  The object type depends on the @code{method} (see below).  For example, when using the @var{url-fetch} method of @code{(guix download)}, the valid @code{uri} values are: a URL represented as a string, or a list thereof."
msgstr "Um objeto contendo o URI da fonte. O tipo de objeto depende do @code{method} (veja abaixo). Por exemplo, ao usar o método @var{url-fetch} de @code{(guix download)}, os valores válidos de @code{uri} são: uma URL representada como uma string, ou uma lista delas."

msgid "fixed-output derivations, for download"
msgstr "derivações de saída fixa, para download"

msgid "method"
msgstr "method"

msgid "A monadic procedure that handles the given URI@.  The procedure must accept at least three arguments: the value of the @code{uri} field and the hash algorithm and hash value specified by the @code{hash} field.  It must return a store item or a derivation in the store monad (@pxref{The Store Monad}); most methods return a fixed-output derivation (@pxref{Derivations})."
msgstr "Um procedimento monádico que manipula o URI fornecido. O procedimento deve aceitar pelo menos três argumentos: o valor do campo @code{uri} e o algoritmo de hash e o valor de hash especificados pelo campo @code{hash}. Ele deve retornar um item do armazém ou uma derivação na mônada do armazém (@pxref{The Store Monad}); a maioria dos métodos retorna uma derivação de saída fixa (@pxref{Derivations})."

msgid "Commonly used methods include @code{url-fetch}, which fetches data from a URL, and @code{git-fetch}, which fetches data from a Git repository (see below)."
msgstr "Os métodos comumente usados incluem @code{url-fetch}, que busca dados de uma URL, e @code{git-fetch}, que busca dados de um repositório Git (veja abaixo)."

msgid "sha256"
msgstr "sha256"

msgid "A bytevector containing the SHA-256 hash of the source.  This is equivalent to providing a @code{content-hash} SHA256 object in the @code{hash} field described below."
msgstr "Um bytevector contendo o hash SHA-256 da fonte. Isso é equivalente a fornecer um objeto SHA256 @code{content-hash} no campo @code{hash} descrito abaixo."

msgid "hash"
msgstr "hash"

msgid "The @code{content-hash} object of the source---see below for how to use @code{content-hash}."
msgstr "O objeto @code{content-hash} da fonte — veja abaixo como usar @code{content-hash}."

msgid "@code{file-name} (default: @code{#f})"
msgstr "@code{file-name} (padrão: @code{#f})"

msgid "The file name under which the source code should be saved.  When this is @code{#f}, a sensible default value will be used in most cases.  In case the source is fetched from a URL, the file name from the URL will be used.  For version control checkouts, it is recommended to provide the file name explicitly because the default is not very descriptive."
msgstr "O nome do arquivo sob o qual o código-fonte deve ser salvo. Quando for @code{#f}, um valor padrão sensato será usado na maioria dos casos. Caso a fonte seja obtida de uma URL, o nome do arquivo da URL será usado. Para checkouts de controle de versão, é recomendado fornecer o nome do arquivo explicitamente porque o padrão não é muito descritivo."

msgid "@code{patches} (default: @code{'()})"
msgstr "@code{patches} (padrão: @code{'()})"

msgid "A list of file names, origins, or file-like objects (@pxref{G-Expressions, file-like objects}) pointing to patches to be applied to the source."
msgstr "Uma lista de nomes de arquivos, origens ou objetos tipo arquivo (@pxref{G-Expressions, objetos tipo arquivo}) apontando para remendos a serem aplicados à origem."

msgid "This list of patches must be unconditional.  In particular, it cannot depend on the value of @code{%current-system} or @code{%current-target-system}."
msgstr "Esta lista de remendos deve ser incondicional. Em particular, não pode depender do valor de @code{%current-system} ou @code{%current-target-system}."

msgid "@code{snippet} (default: @code{#f})"
msgstr "@code{snippet} (padrão: @code{#f})"

msgid "A G-expression (@pxref{G-Expressions}) or S-expression that will be run in the source directory.  This is a convenient way to modify the source, sometimes more convenient than a patch."
msgstr "Uma expressão G (@pxref{G-Expressions}) ou expressão S que será executada no diretório de origem. Esta é uma maneira conveniente de modificar a origem, às vezes mais conveniente do que um patch."

msgid "@code{patch-flags} (default: @code{'(\"-p1\")})"
msgstr "@code{patch-flags} (padrão: @code{'(\"-p1\")})"

msgid "A list of command-line flags that should be passed to the @code{patch} command."
msgstr "Uma lista de sinalizadores de linha de comando que devem ser passados para o comando @code{patch}."

msgid "@code{patch-inputs} (default: @code{#f})"
msgstr "@code{patch-inputs} (padrão: @code{#f})"

msgid "Input packages or derivations to the patching process.  When this is @code{#f}, the usual set of inputs necessary for patching are provided, such as GNU@tie{}Patch."
msgstr "Pacotes de entrada ou derivações para o processo de patching. Quando este é @code{#f}, o conjunto usual de entradas necessárias para patching é fornecido, como GNU@tie{}Patch."

msgid "@code{modules} (default: @code{'()})"
msgstr "@code{modules} (padrão: @code{'()})"

msgid "A list of Guile modules that should be loaded during the patching process and while running the code in the @code{snippet} field."
msgstr "Uma lista de módulos Guile que devem ser carregados durante o processo de aplicação de remendos e durante a execução do código no campo @code{snippet}."

msgid "@code{patch-guile} (default: @code{#f})"
msgstr "@code{patch-guile} (padrão: @code{#f})"

msgid "The Guile package that should be used in the patching process.  When this is @code{#f}, a sensible default is used."
msgstr "O pacote Guile que deve ser usado no processo de patching. Quando este é @code{#f}, um padrão sensato é usado."

msgid "{Data Type} content-hash @var{value} [@var{algorithm}]"
msgstr "{Tipo de dados} content-hash @var{valor} [@var{algoritmo}]"

msgid "Construct a content hash object for the given @var{algorithm}, and with @var{value} as its hash value.  When @var{algorithm} is omitted, assume it is @code{sha256}."
msgstr "Construa um objeto hash de conteúdo para o @var{algoritmo} fornecido, e com @var{valor} como seu valor hash. Quando @var{algoritmo} é omitido, presuma que é @code{sha256}."

msgid "@var{value} can be a literal string, in which case it is base32-decoded, or it can be a bytevector."
msgstr "@var{valor} pode ser uma string literal, nesse caso ela é decodificada em base32, ou pode ser um bytevector."

msgid "The following forms are all equivalent:"
msgstr "Os seguintes formulários são todos equivalentes:"

msgid ""
"(content-hash \"05zxkyz9bv3j9h0xyid1rhvh3klhsmrpkf3bcs6frvlgyr2gwilj\")\n"
"(content-hash \"05zxkyz9bv3j9h0xyid1rhvh3klhsmrpkf3bcs6frvlgyr2gwilj\"\n"
"              sha256)\n"
"(content-hash (base32\n"
"               \"05zxkyz9bv3j9h0xyid1rhvh3klhsmrpkf3bcs6frvlgyr2gwilj\"))\n"
"(content-hash (base64 \"kkb+RPaP7uyMZmu4eXPVkM4BN8yhRd8BTHLslb6f/Rc=\")\n"
"              sha256)\n"
msgstr ""
"(content-hash \"05zxkyz9bv3j9h0xyid1rhvh3klhsmrpkf3bcs6frvlgyr2gwilj\")\n"
"(content-hash \"05zxkyz9bv3j9h0xyid1rhvh3klhsmrpkf3bcs6frvlgyr2gwilj\"\n"
"              sha256)\n"
"(content-hash (base32\n"
"               \"05zxkyz9bv3j9h0xyid1rhvh3klhsmrpkf3bcs6frvlgyr2gwilj\"))\n"
"(content-hash (base64 \"kkb+RPaP7uyMZmu4eXPVkM4BN8yhRd8BTHLslb6f/Rc=\")\n"
"              sha256)\n"

msgid "Technically, @code{content-hash} is currently implemented as a macro.  It performs sanity checks at macro-expansion time, when possible, such as ensuring that @var{value} has the right size for @var{algorithm}."
msgstr "Tecnicamente, @code{content-hash} é atualmente implementado como uma macro. Ele realiza verificações de sanidade no momento da expansão da macro, quando possível, como garantir que @var{valor} tenha o tamanho certo para @var{algoritmo}."

msgid "As we have seen above, how exactly the data an origin refers to is retrieved is determined by its @code{method} field.  The @code{(guix download)} module provides the most common method, @code{url-fetch}, described below."
msgstr "Como vimos acima, como exatamente os dados aos quais uma origem se refere são recuperados é determinado pelo seu campo @code{method}. O módulo @code{(guix download)} fornece o método mais comum, @code{url-fetch}, descrito abaixo."

msgid "{Procedure} url-fetch url hash-algo hash [name] [#:executable? #f]"
msgstr "{Procedimento} url-fetch url hash-algo hash [nome] [#:executable?? #f]"

msgid "Return a fixed-output derivation that fetches data from @var{url} (a string, or a list of strings denoting alternate URLs), which is expected to have hash @var{hash} of type @var{hash-algo} (a symbol).  By default, the file name is the base name of URL; optionally, @var{name} can specify a different file name.  When @var{executable?} is true, make the downloaded file executable."
msgstr "Retorna uma derivação de saída fixa que busca dados de @var{url} (uma string, ou uma lista de strings denotando URLs alternativas), que deve ter hash @var{hash} do tipo @var{hash-algo} (um símbolo). Por padrão, o nome do arquivo é o nome base de URL; opcionalmente, @var{nome} pode especificar um nome de arquivo diferente. Quando @var{executable?} é verdadeiro, torna o arquivo baixado executável."

msgid "When one of the URL starts with @code{mirror://}, then its host part is interpreted as the name of a mirror scheme, taken from @file{%mirror-file}."
msgstr "Quando uma das URLs começa com @code{mirror://}, sua parte host é interpretada como o nome de um esquema de espelho, obtido de @file{%mirror-file}."

msgid "Alternatively, when URL starts with @code{file://}, return the corresponding file name in the store."
msgstr "Como alternativa, quando a URL começa com @code{file://}, retorne o nome do arquivo correspondente no armazém."

msgid "Likewise, the @code{(guix git-download)} module defines the @code{git-fetch} origin method, which fetches data from a Git version control repository, and the @code{git-reference} data type to describe the repository and revision to fetch."
msgstr "Da mesma forma, o módulo @code{(guix git-download)} define o método de origem @code{git-fetch}, que busca dados de um repositório de controle de versão Git, e o tipo de dados @code{git-reference} para descrever o repositório e a revisão a serem buscados."

msgid "{Procedure} git-fetch ref hash-algo hash [name]"
msgstr "{Procedimento} git-fetch ref hash-algo hash [nome]"

msgid "Return a fixed-output derivation that fetches @var{ref}, a @code{<git-reference>} object.  The output is expected to have recursive hash @var{hash} of type @var{hash-algo} (a symbol).  Use @var{name} as the file name, or a generic name if @code{#f}."
msgstr "Retorna uma derivação de saída fixa que busca @var{ref}, um objeto @code{<git-reference>}. Espera-se que a saída tenha hash recursivo @var{hash} do tipo @var{hash-algo} (um símbolo). Use @var{nome} como o nome do arquivo, ou um nome genérico se @code{#f}."

msgid "{Procedure} git-fetch/lfs ref hash-algo hash [name]"
msgstr "{Procedimento} git-fetch/lfs ref hash-algo hash [nome]"

msgid "This is a variant of the @code{git-fetch} procedure that supports the Git @acronym{LFS, Large File Storage} extension.  This may be useful to pull some binary test data to run the test suite of a package, for example."
msgstr "Esta é uma variante do procedimento @code{git-fetch} que suporta a extensão Git @acronym{LFS, Large File Storage}. Isso pode ser útil para extrair alguns dados de teste binários para executar o conjunto de testes de um pacote, por exemplo."

msgid "{Data Type} git-reference"
msgstr "{Tipo de dados} git-reference"

msgid "This data type represents a Git reference for @code{git-fetch} to retrieve."
msgstr "Este tipo de dado representa uma referência Git para @code{git-fetch} a recuperar."

msgid "url"
msgstr "url"

msgid "The URL of the Git repository to clone."
msgstr "A URL do repositório Git a ser clonado."

msgid "commit"
msgstr "commit"

msgid "This string denotes either the commit to fetch (a hexadecimal string), or the tag to fetch.  You can also use a ``short'' commit ID or a @command{git describe} style identifier such as @code{v1.0.1-10-g58d7909c97}."
msgstr "Esta string denota o commit a ser buscado (uma string hexadecimal) ou a tag a ser buscada. Você também pode usar um ID de commit ``curto'' ou um identificador de estilo @command{git describe} como @code{v1.0.1-10-g58d7909c97}."

msgid "@code{recursive?} (default: @code{#f})"
msgstr "@code{recursive?} (padrão: @code{#f})"

msgid "This Boolean indicates whether to recursively fetch Git sub-modules."
msgstr "Este booleano indica se os submódulos do Git devem ser buscados recursivamente."

msgid "The example below denotes the @code{v2.10} tag of the GNU@tie{}Hello repository:"
msgstr "O exemplo abaixo denota a tag @code{v2.10} do repositório GNU@tie{}Hello:"

msgid ""
"(git-reference\n"
"  (url \"https://git.savannah.gnu.org/git/hello.git\")\n"
"  (commit \"v2.10\"))\n"
msgstr ""
"(git-reference\n"
"  (url \"https://git.savannah.gnu.org/git/hello.git\")\n"
"  (commit \"v2.10\"))\n"

msgid "This is equivalent to the reference below, which explicitly names the commit:"
msgstr "Isso é equivalente à referência abaixo, que nomeia explicitamente o commit:"

msgid ""
"(git-reference\n"
"  (url \"https://git.savannah.gnu.org/git/hello.git\")\n"
"  (commit \"dc7dc56a00e48fe6f231a58f6537139fe2908fb9\"))\n"
msgstr ""
"(git-reference\n"
"  (url \"https://git.savannah.gnu.org/git/hello.git\")\n"
"  (commit \"dc7dc56a00e48fe6f231a58f6537139fe2908fb9\"))\n"

msgid "For Mercurial repositories, the module @code{(guix hg-download)} defines the @code{hg-fetch} origin method and @code{hg-reference} data type for support of the Mercurial version control system."
msgstr "Para repositórios Mercurial, o módulo @code{(guix hg-download)} define o método de origem @code{hg-fetch} e o tipo de dados @code{hg-reference} para suporte ao sistema de controle de versão Mercurial."

msgid "{Procedure} hg-fetch ref hash-algo hash [name]"
msgstr "{Procedimento} hg-fetch ref hash-algo hash [nome]"

msgid "Return a fixed-output derivation that fetches @var{ref}, a @code{<hg-reference>} object.  The output is expected to have recursive hash @var{hash} of type @var{hash-algo} (a symbol).  Use @var{name} as the file name, or a generic name if @code{#f}."
msgstr "Retorna uma derivação de saída fixa que busca @var{ref}, um objeto @code{<hg-reference>}. Espera-se que a saída tenha hash recursivo @var{hash} do tipo @var{hash-algo} (um símbolo). Use @var{nome} como o nome do arquivo, ou um nome genérico se @code{#f}."

msgid "{Data Type} hg-reference"
msgstr "{Tipo de dados} hg-reference"

msgid "This data type represents a Mercurial reference for @code{hg-fetch} to retrieve."
msgstr "Este tipo de dado representa uma referência Mercurial para @code{hg-fetch} a recuperar."

msgid "The URL of the Mercurial repository to clone."
msgstr "A URL do repositório Mercurial a ser clonado."

msgid "changeset"
msgstr "changeset"

msgid "This string denotes the changeset to fetch."
msgstr "Esta sequência de caracteres indica a revisão a ser buscado."

msgid "For Subversion repositories, the module @code{(guix svn-download)} defines the @code{svn-fetch} origin method and @code{svn-reference} data type for support of the Subversion version control system."
msgstr "Para repositórios Subversion, o módulo @code{(guix svn-download)} define o método de origem @code{svn-fetch} e o tipo de dados @code{svn-reference} para suporte ao sistema de controle de versão Subversion."

msgid "{Procedure} svn-fetch ref hash-algo hash [name]"
msgstr "{Procedimento} svn-fetch ref hash-algo hash [nome]"

msgid "Return a fixed-output derivation that fetches @var{ref}, a @code{<svn-reference>} object.  The output is expected to have recursive hash @var{hash} of type @var{hash-algo} (a symbol).  Use @var{name} as the file name, or a generic name if @code{#f}."
msgstr "Retorna uma derivação de saída fixa que busca @var{ref}, um objeto @code{<svn-reference>}. Espera-se que a saída tenha hash recursivo @var{hash} do tipo @var{hash-algo} (um símbolo). Use @var{nome} como o nome do arquivo, ou um nome genérico se @code{#f}."

msgid "{Data Type} svn-reference"
msgstr "{Tipo de dados} svn-reference"

msgid "This data type represents a Subversion reference for @code{svn-fetch} to retrieve."
msgstr "Este tipo de dado representa uma referência Subversion para @code{svn-fetch} a recuperar."

msgid "The URL of the Subversion repository to clone."
msgstr "A URL do repositório Subversion a ser clonado."

msgid "revision"
msgstr "revision"

msgid "This string denotes the revision to fetch specified as a number."
msgstr "Esta sequência de caracteres denota a revisão a ser buscada especificada como um número."

msgid "This Boolean indicates whether to recursively fetch Subversion ``externals''."
msgstr "Este booleano indica se deve-se buscar recursivamente ``externals'' do Subversion."

msgid "@code{user-name} (default: @code{#f})"
msgstr "@code{user-name} (padrão: @code{#f})"

msgid "The name of an account that has read-access to the repository, if the repository isn't public."
msgstr "O nome de uma conta que tem acesso de leitura ao repositório, se o repositório não for público."

msgid "@code{password} (default: @code{#f})"
msgstr "@code{password} (padrão: @code{#f})"

msgid "Password to access the Subversion repository, if required."
msgstr "Senha para acessar o repositório Subversion, se necessário."

msgid "For Bazaar repositories, the module @code{(guix bzr-download)} defines the @code{bzr-fetch} origin method and @code{bzr-reference} data type for support of the Bazaar version control system."
msgstr "Para repositórios Bazaar, o módulo @code{(guix bzr-download)} define o método de origem @code{bzr-fetch} e o tipo de dados @code{bzr-reference} para suporte ao sistema de controle de versão Bazaar."

msgid "{Procedure} bzr-fetch ref hash-algo hash [name]"
msgstr "{Procedimento} bzr-fetch ref hash-algo hash [nome]"

msgid "Return a fixed-output derivation that fetches @var{ref}, a @code{<bzr-reference>} object.  The output is expected to have recursive hash @var{hash} of type @var{hash-algo} (a symbol).  Use @var{name} as the file name, or a generic name if @code{#f}."
msgstr "Retorna uma derivação de saída fixa que busca @var{ref}, um objeto @code{<bzr-reference>}. Espera-se que a saída tenha hash recursivo @var{hash} do tipo @var{hash-algo} (um símbolo). Use @var{nome} como o nome do arquivo, ou um nome genérico se @code{#f}."

msgid "{Data Type} bzr-reference"
msgstr "{Tipo de dados} bzr-reference"

msgid "This data type represents a Bazaar reference for @code{bzr-fetch} to retrieve."
msgstr "Este tipo de dado representa uma referência Bazaar para @code{bzr-fetch} a recuperar."

msgid "The URL of the Bazaar repository to clone."
msgstr "A URL do repositório Bazaar a ser clonado."

msgid "This string denotes revision to fetch specified as a number."
msgstr "Esta sequência de caracteres denota a revisão a ser buscada especificada como um número."

msgid "For CVS repositories, the module @code{(guix cvs-download)} defines the @code{cvs-fetch} origin method and @code{cvs-reference} data type for support of the Concurrent Versions System (CVS)."
msgstr "Para repositórios CVS, o módulo @code{(guix cvs-download)} define o método de origem @code{cvs-fetch} e o tipo de dados @code{cvs-reference} para suporte ao Concurrent Versions System (CVS)."

msgid "{Procedure} cvs-fetch ref hash-algo hash [name]"
msgstr "{Procedimento} cvs-fetch ref hash-algo hash [nome]"

msgid "Return a fixed-output derivation that fetches @var{ref}, a @code{<cvs-reference>} object.  The output is expected to have recursive hash @var{hash} of type @var{hash-algo} (a symbol).  Use @var{name} as the file name, or a generic name if @code{#f}."
msgstr "Retorna uma derivação de saída fixa que busca @var{ref}, um objeto @code{<cvs-reference>}. Espera-se que a saída tenha hash recursivo @var{hash} do tipo @var{hash-algo} (um símbolo). Use @var{nome} como o nome do arquivo, ou um nome genérico se @code{#f}."

msgid "{Data Type} cvs-reference"
msgstr "{Tipo de dados} cvs-reference"

msgid "This data type represents a CVS reference for @code{cvs-fetch} to retrieve."
msgstr "Este tipo de dado representa uma referência CVS para @code{cvs-fetch} a recuperar."

msgid "root-directory"
msgstr "root-directory"

msgid "The CVS root directory."
msgstr "O diretório raiz do CVS."

msgid "module"
msgstr "module"

msgid "Module to fetch."
msgstr "Módulo a ser buscado."

msgid "Revision to fetch."
msgstr "Revisão para buscar."

msgid "The example below denotes a version of gnu-standards to fetch:"
msgstr "O exemplo abaixo denota uma versão do gnu-standards para buscar:"

msgid ""
"(cvs-reference\n"
"  (root-directory \":pserver:anonymous@@cvs.savannah.gnu.org:/sources/gnustandards\")\n"
"  (module \"gnustandards\")\n"
"  (revision \"2020-11-25\"))\n"
msgstr ""
"(cvs-reference\n"
"  (root-directory \":pserver:anonymous@@cvs.savannah.gnu.org:/sources/gnustandards\")\n"
"  (module \"gnustandards\")\n"
"  (revision \"2020-11-25\"))\n"

msgid "customizing packages"
msgstr "personalizando pacotes"

msgid "package variants"
msgstr "variantes de pacotes"

msgid "variants, of packages"
msgstr "variantes, de pacotes"

msgid "One of the nice things with Guix is that, given a package definition, you can easily @emph{derive} variants of that package---for a different upstream version, with different dependencies, different compilation options, and so on.  Some of these custom packages can be defined straight from the command line (@pxref{Package Transformation Options}).  This section describes how to define package variants in code.  This can be useful in ``manifests'' (@pxref{Writing Manifests})  and in your own package collection (@pxref{Creating a Channel}), among others!"
msgstr "Uma das coisas boas com o Guix é que, dada uma definição de pacote, você pode facilmente @emph{derivar} variantes desse pacote---para uma versão upstream diferente, com dependências diferentes, opções de compilação diferentes e assim por diante. Alguns desses pacotes personalizados podem ser definidos diretamente da linha de comando (@pxref{Package Transformation Options}). Esta seção descreve como definir variantes de pacotes no código. Isso pode ser útil em ``manifestos'' (@pxref{Writing Manifests}) e em sua própria coleção de pacotes (@pxref{Creating a Channel}), entre outros!"

msgid "inherit, for package definitions"
msgstr "herdar, para definições de pacotes"

msgid "As discussed earlier, packages are first-class objects in the Scheme language.  The @code{(guix packages)} module provides the @code{package} construct to define new package objects (@pxref{package Reference}).  The easiest way to define a package variant is using the @code{inherit} keyword together with @code{package}.  This allows you to inherit from a package definition while overriding the fields you want."
msgstr "Conforme discutido anteriormente, os pacotes são objetos de primeira classe na linguagem Scheme. O módulo @code{(guix packages)} fornece a construção @code{package} para definir novos objetos de pacote (@pxref{package Reference}). A maneira mais fácil de definir uma variante de pacote é usando a palavra-chave @code{inherit} junto com @code{package}. Isso permite que você herde de uma definição de pacote enquanto substitui os campos que deseja."

msgid "For example, given the @code{hello} variable, which contains a definition for the current version of GNU@tie{}Hello, here's how you would define a variant for version 2.2 (released in 2006, it's vintage!):"
msgstr "Por exemplo, dada a variável @code{hello}, que contém uma definição para a versão atual do GNU@tie{}Hello, veja como você definiria uma variante para a versão 2.2 (lançada em 2006, é vintage!):"

msgid ""
"(use-modules (gnu packages base))    ;for 'hello'\n"
"\n"
msgstr ""
"(use-modules (gnu packages base))    ;para 'hello'\n"
"\n"

msgid ""
"(define hello-2.2\n"
"  (package\n"
"    (inherit hello)\n"
"    (version \"2.2\")\n"
"    (source (origin\n"
"              (method url-fetch)\n"
"              (uri (string-append \"mirror://gnu/hello/hello-\" version\n"
"                                  \".tar.gz\"))\n"
"              (sha256\n"
"               (base32\n"
"                \"0lappv4slgb5spyqbh6yl5r013zv72yqg2pcl30mginf3wdqd8k9\"))))))\n"
msgstr ""
"(define hello-2.2\n"
"  (package\n"
"    (inherit hello)\n"
"    (version \"2.2\")\n"
"    (source (origin\n"
"              (method url-fetch)\n"
"              (uri (string-append \"mirror://gnu/hello/hello-\" version\n"
"                                  \".tar.gz\"))\n"
"              (sha256\n"
"               (base32\n"
"                \"0lappv4slgb5spyqbh6yl5r013zv72yqg2pcl30mginf3wdqd8k9\"))))))\n"

msgid "The example above corresponds to what the @option{--with-version} or @option{--with-source} package transformations option do.  Essentially @code{hello-2.2} preserves all the fields of @code{hello}, except @code{version} and @code{source}, which it overrides.  Note that the original @code{hello} variable is still there, in the @code{(gnu packages base)} module, unchanged.  When you define a custom package like this, you are really @emph{adding} a new package definition; the original one remains available."
msgstr "O exemplo acima corresponde ao que as opções de transformação de pacote @option{--with-version} ou @option{--with-source} fazem. Essencialmente, @code{hello-2.2} preserva todos os campos de @code{hello}, exceto @code{version} e @code{source}, que ele substitui. Observe que a variável @code{hello} original ainda está lá, no módulo @code{(gnu packages base)}, inalterada. Quando você define um pacote personalizado como este, você está realmente @emph{adicionando} uma nova definição de pacote; a original permanece disponível."

msgid "You can just as well define variants with a different set of dependencies than the original package.  For example, the default @code{gdb} package depends on @code{guile}, but since that is an optional dependency, you can define a variant that removes that dependency like so:"
msgstr "Você pode também definir variantes com um conjunto diferente de dependências do que o pacote original. Por exemplo, o pacote padrão @code{gdb} depende de @code{guile}, mas como essa é uma dependência opcional, você pode definir uma variante que remova essa dependência assim:"

msgid ""
"(use-modules (gnu packages gdb))   ;for 'gdb'\n"
"\n"
msgstr ""
"(use-modules (gnu packages gdb))   ;para 'gdb'\n"
"\n"

msgid "modify-inputs inputs clauses"
msgstr "modify-inputs entradas cláusulas"

msgid "Modify the given package inputs, as returned by @code{package-inputs} & co., according to the given clauses.  Each clause must have one of the following forms:"
msgstr "Modifique as entradas do pacote fornecido, conforme retornado por @code{package-inputs} & co., de acordo com as cláusulas fornecidas. Cada cláusula deve ter uma das seguintes formas:"

msgid "(delete @var{name}@dots{})"
msgstr "(delete @var{nome}@dots{})"

msgid "Delete from the inputs packages with the given @var{name}s (strings)."
msgstr "Exclua dos pacotes de entrada os @var{nome}s (strings) fornecidos."

msgid "(prepend @var{package}@dots{})"
msgstr "(prepend @var{pacote}@dots{})"

msgid "Add @var{package}s to the front of the input list."
msgstr "Adicione @var{pacote}s à frente da lista de entrada."

msgid "(append @var{package}@dots{})"
msgstr "(append @var{pacote}@dots{})"

msgid "Add @var{package}s to the end of the input list."
msgstr "Adicione @var{pacote}s ao final da lista de entrada."

msgid "(replace @var{name} @var{replacement})"
msgstr "(replace @var{nome} @var{substituição})"

msgid "Replace the package called @var{name} with @var{replacement}."
msgstr "Substitua o pacote chamado @var{nome} por @var{substituição}."

msgid "The example below removes the GMP and ACL inputs of Coreutils and adds libcap to the front of the input list:"
msgstr "O exemplo abaixo remove as entradas GMP e ACL do Coreutils e adiciona libcap à frente da lista de entradas:"

msgid ""
"(modify-inputs (package-inputs coreutils)\n"
"  (delete \"gmp\" \"acl\")\n"
"  (prepend libcap))\n"
msgstr ""
"(modify-inputs (package-inputs coreutils)\n"
"  (delete \"gmp\" \"acl\")\n"
"  (prepend libcap))\n"

msgid "The example below replaces the @code{guile} package from the inputs of @code{guile-redis} with @code{guile-2.2}:"
msgstr "O exemplo abaixo substitui o pacote @code{guile} das entradas de @code{guile-redis} por @code{guile-2.2}:"

msgid ""
"(modify-inputs (package-inputs guile-redis)\n"
"  (replace \"guile\" guile-2.2))\n"
msgstr ""
"(modify-inputs (package-inputs guile-redis)\n"
"  (replace \"guile\" guile-2.2))\n"

msgid "In some cases, you may find it useful to write functions (``procedures'', in Scheme parlance) that return a package based on some parameters.  For example, consider the @code{luasocket} library for the Lua programming language.  We want to create @code{luasocket} packages for major versions of Lua.  One way to do that is to define a procedure that takes a Lua package and returns a @code{luasocket} package that depends on it:"
msgstr "Em alguns casos, você pode achar útil escrever funções (``procedimentos'', no jargão do Scheme) que retornam um pacote com base em alguns parâmetros. Por exemplo, considere a biblioteca @code{luasocket} para a linguagem de programação Lua. Queremos criar pacotes @code{luasocket} para as principais versões do Lua. Uma maneira de fazer isso é definir um procedimento que pega um pacote Lua e retorna um pacote @code{luasocket} que depende dele:"

msgid "Here we have defined packages @code{lua5.1-socket} and @code{lua5.2-socket} by calling @code{make-lua-socket} with different arguments.  @xref{Procedures,,, guile, GNU Guile Reference Manual}, for more info on procedures.  Having top-level public definitions for these two packages means that they can be referred to from the command line (@pxref{Package Modules})."
msgstr "Aqui definimos os pacotes @code{lua5.1-socket} e @code{lua5.2-socket} chamando @code{make-lua-socket} com argumentos diferentes. @xref{Procedures,,, guile, GNU Guile Reference Manual}, para mais informações sobre procedimentos. Ter definições públicas de nível superior para esses dois pacotes significa que eles podem ser referenciados a partir da linha de comando (@pxref{Package Modules})."

msgid "package transformations"
msgstr "transformações de pacotes"

msgid "These are pretty simple package variants.  As a convenience, the @code{(guix transformations)} module provides a high-level interface that directly maps to the more sophisticated package transformation options (@pxref{Package Transformation Options}):"
msgstr "Essas são variantes de pacote bem simples. Como uma conveniência, o módulo @code{(guix transformations)} fornece uma interface de alto nível que mapeia diretamente para as opções de transformação de pacote mais sofisticadas (@pxref{Package Transformation Options}):"

msgid "{Procedure} options->transformation opts"
msgstr "{Procedimento} options->transformation opções"

msgid "Return a procedure that, when passed an object to build (package, derivation, etc.), applies the transformations specified by @var{opts} and returns the resulting objects.  @var{opts} must be a list of symbol/string pairs such as:"
msgstr "Retorna um procedimento que, quando passado um objeto para construção (pacote, derivação, etc.), aplica as transformações especificadas por @var{opções} e retorna os objetos resultantes. @var{opções} deve ser uma lista de pares símbolo/string como:"

msgid ""
"((with-branch . \"guile-gcrypt=master\")\n"
" (without-tests . \"libgcrypt\"))\n"
msgstr ""
"((with-branch . \"guile-gcrypt=master\")\n"
" (without-tests . \"libgcrypt\"))\n"

msgid "Each symbol names a transformation and the corresponding string is an argument to that transformation."
msgstr "Cada símbolo nomeia uma transformação e a string correspondente é um argumento para essa transformação."

msgid "For instance, a manifest equivalent to this command:"
msgstr "Por exemplo, um manifesto equivalente a este comando:"

msgid ""
"guix build guix \\\n"
"  --with-branch=guile-gcrypt=master \\\n"
"  --with-debug-info=zlib\n"
msgstr ""
"guix build guix \\\n"
"  --with-branch=guile-gcrypt=master \\\n"
"  --with-debug-info=zlib\n"

msgid "... would look like this:"
msgstr "... ficaria assim:"

msgid ""
"(use-modules (guix transformations))\n"
"\n"
msgstr ""
"(use-modules (guix transformations))\n"
"\n"

msgid ""
"(packages->manifest\n"
" (list (transform (specification->package \"guix\"))))\n"
msgstr ""
"(packages->manifest\n"
" (list (transform (specification->package \"guix\"))))\n"

msgid "input rewriting"
msgstr "reescrita de entrada"

msgid "dependency graph rewriting"
msgstr "reescrita de grafo de dependência"

msgid "The @code{options->transformation} procedure is convenient, but it's perhaps also not as flexible as you may like.  How is it implemented? The astute reader probably noticed that most package transformation options go beyond the superficial changes shown in the first examples of this section: they involve @dfn{input rewriting}, whereby the dependency graph of a package is rewritten by replacing specific inputs by others."
msgstr "O procedimento @code{options->transformation} é conveniente, mas talvez também não seja tão flexível quanto você gostaria. Como ele é implementado? O leitor astuto provavelmente notou que a maioria das opções de transformação de pacotes vai além das mudanças superficiais mostradas nos primeiros exemplos desta seção: elas envolvem @dfn{reescrita de entrada}, por meio da qual o grafo de dependência de um pacote é reescrito pela substituição de entradas específicas por outras."

msgid "Dependency graph rewriting, for the purposes of swapping packages in the graph, is what the @code{package-input-rewriting} procedure in @code{(guix packages)} implements."
msgstr "A reescrita do grafo de dependência, para fins de troca de pacotes no grafo, é o que o procedimento @code{package-input-rewriting} em @code{(guix packages)} implementa."

msgid "{Procedure} package-input-rewriting replacements [rewrite-name] @"
msgstr "{Procedimento} package-input-rewriting substituições [nome-da-reescrita] @"

msgid "[#:deep? #t] [#:recursive? #f] Return a procedure that, when passed a package, replaces its direct and indirect dependencies, including implicit inputs when @var{deep?} is true, according to @var{replacements}.  @var{replacements} is a list of package pairs; the first element of each pair is the package to replace, and the second one is the replacement."
msgstr ""
"[#:deep? #t] [#:recursive? #f]\n"
"Retorna um procedimento que, quando recebe um pacote, substitui suas dependências diretas e indiretas, incluindo entradas implícitas quando @var{deep?} é verdadeiro, de acordo com @var{substituições}. @var{substituições} é uma lista de pares de pacotes; o primeiro elemento de cada par é o pacote a ser substituído, e o segundo é a substituição."

msgid "Optionally, @var{rewrite-name} is a one-argument procedure that takes the name of a package and returns its new name after rewrite."
msgstr "Opcionalmente, @var{nome-da-reescrita} é um procedimento de um argumento que recebe o nome de um pacote e retorna seu novo nome após a reescrita."

msgid "Consider this example:"
msgstr "Considere este exemplo:"

msgid "Here we first define a rewriting procedure that replaces @var{openssl} with @var{libressl}.  Then we use it to define a @dfn{variant} of the @var{git} package that uses @var{libressl} instead of @var{openssl}.  This is exactly what the @option{--with-input} command-line option does (@pxref{Package Transformation Options, @option{--with-input}})."
msgstr "Aqui, primeiro definimos um procedimento de reescrita que substitui @var{openssl} por @var{libressl}. Então, o usamos para definir uma @dfn{variante} do pacote @var{git} que usa @var{libressl} em vez de @var{openssl}. É exatamente isso que a opção de linha de comando @option{--with-input} faz (@pxref{Package Transformation Options, @option{--with-input}})."

msgid "The following variant of @code{package-input-rewriting} can match packages to be replaced by name rather than by identity."
msgstr "A seguinte variante de @code{package-input-rewriting} pode corresponder a pacotes a serem substituídos por nome em vez de identidade."

msgid "{Procedure} package-input-rewriting/spec @var{replacements} @"
msgstr "{Procedimento} package-input-rewriting/spec @var{substituições} @"

msgid "[#:deep? #t] [#:replace-hidden? #t] Return a procedure that, given a package, applies the given @var{replacements} to all the package graph, including implicit inputs unless @var{deep?} is false."
msgstr ""
"[#:deep? #t] [#:replace-hidden? #t]\n"
"Retorna um procedimento que, dado um pacote, aplica as @var{substituições} fornecidas a todo o grafo do pacote, incluindo entradas implícitas, a menos que @var{deep?} seja falso."

msgid "The example above could be rewritten this way:"
msgstr "O exemplo acima poderia ser reescrito desta forma:"

msgid ""
"(define libressl-instead-of-openssl\n"
"  ;; Replace all the packages called \"openssl\" with LibreSSL.\n"
"  (package-input-rewriting/spec `((\"openssl\" . ,(const libressl)))))\n"
msgstr ""
"(define libressl-instead-of-openssl\n"
"  ;; Substitua todos os pacotes chamados \"openssl\" por LibreSSL.\n"
"  (package-input-rewriting/spec `((\"openssl\" . ,(const libressl)))))\n"

msgid "The key difference here is that, this time, packages are matched by spec and not by identity.  In other words, any package in the graph that is called @code{openssl} will be replaced."
msgstr "A principal diferença aqui é que, dessa vez, os pacotes são correspondidos por spec e não por identidade. Em outras palavras, qualquer pacote no grafo que seja chamado @code{openssl} será substituído."

msgid "A more generic procedure to rewrite a package dependency graph is @code{package-mapping}: it supports arbitrary changes to nodes in the graph."
msgstr "Um procedimento mais genérico para reescrever um grafo de dependência de pacote é @code{package-mapping}: ele suporta alterações arbitrárias em nós no grafo."

msgid "{Procedure} package-mapping proc [cut?] [#:deep? #f]"
msgstr "{Procedimento} package-mapping proc [cortar?] [#:deep? #f]"

msgid "Return a procedure that, given a package, applies @var{proc} to all the packages depended on and returns the resulting package.  The procedure stops recursion when @var{cut?} returns true for a given package.  When @var{deep?} is true, @var{proc} is applied to implicit inputs as well."
msgstr "Retorna um procedimento que, dado um pacote, aplica @var{proc} a todos os pacotes dependentes e retorna o pacote resultante. O procedimento para a recursão quando @var{cortar?} retorna true para um determinado pacote. Quando @var{deep?} é true, @var{proc} é aplicado a entradas implícitas também."

msgid "Tips"
msgstr "Dicas"

msgid "Understanding what a variant really looks like can be difficult as one starts combining the tools shown above.  There are several ways to inspect a package before attempting to build it that can prove handy:"
msgstr "Entender como uma variante realmente se parece pode ser difícil quando se começa a combinar as ferramentas mostradas acima. Há várias maneiras de inspecionar um pacote antes de tentar construí-lo que podem ser úteis:"

msgid "You can inspect the package interactively at the REPL, for instance to view its inputs, the code of its build phases, or its configure flags (@pxref{Using Guix Interactively})."
msgstr "Você pode inspecionar o pacote interativamente no REPL, por exemplo, para visualizar suas entradas, o código de suas fases de construção ou seus sinalizadores de configuração (@pxref{Using Guix Interactively})."

msgid "When rewriting dependencies, @command{guix graph} can often help visualize the changes that are made (@pxref{Invoking guix graph})."
msgstr "Ao reescrever dependências, @command{guix graph} geralmente pode ajudar a visualizar as alterações feitas (@pxref{Invoking guix graph})."

msgid "manifest"
msgstr "manifesto"

msgid "bill of materials (manifests)"
msgstr "lista de materiais (manifestos)"

msgid "@command{guix} commands let you specify package lists on the command line.  This is convenient, but as the command line becomes longer and less trivial, it quickly becomes more convenient to have that package list in what we call a @dfn{manifest}.  A manifest is some sort of a ``bill of materials'' that defines a package set.  You would typically come up with a code snippet that builds the manifest, store it in a file, say @file{manifest.scm}, and then pass that file to the @option{-m} (or @option{--manifest}) option that many @command{guix} commands support.  For example, here's what a manifest for a simple package set might look like:"
msgstr "Os comandos @command{guix} permitem que você especifique listas de pacotes na linha de comando. Isso é conveniente, mas conforme a linha de comando se torna mais longa e menos trivial, rapidamente se torna mais conveniente ter essa lista de pacotes no que chamamos de @dfn{manifesto}. Um manifesto é algum tipo de ``lista de materiais'' que define um conjunto de pacotes. Você normalmente criaria um trecho de código que constrói o manifesto, o armazenaria em um arquivo, digamos @file{manifest.scm}, e então passaria esse arquivo para a opção @option{-m} (ou @option{--manifest}) que muitos comandos @command{guix} suportam. Por exemplo, aqui está como um manifesto para um conjunto de pacotes simples pode se parecer:"

msgid ""
";; Manifest for three packages.\n"
"(specifications->manifest '(\"gcc-toolchain\" \"make\" \"git\"))\n"
msgstr ""
";; Manifesto para três pacotes.\n"
"(specifications->manifest '(\"gcc-toolchain\" \"make\" \"git\"))\n"

msgid "Once you have that manifest, you can pass it, for example, to @command{guix package} to install just those three packages to your profile (@pxref{profile-manifest, @option{-m} option of @command{guix package}}):"
msgstr "Depois de ter esse manifesto, você pode passá-lo, por exemplo, para @command{guix package} para instalar apenas esses três pacotes no seu perfil (@pxref{profile-manifest, @option{-m} opção de @command{guix package}}):"

msgid "guix package -m manifest.scm\n"
msgstr "guix package -m manifest.scm\n"

msgid "... or you can pass it to @command{guix shell} (@pxref{shell-manifest, @command{-m} option of @command{guix shell}}) to spawn an ephemeral environment:"
msgstr "... ou você pode passá-lo para @command{guix shell} (@pxref{shell-manifest, @command{-m} opção de @command{guix shell}}) para gerar um ambiente efêmero:"

msgid "... or you can pass it to @command{guix pack} in pretty much the same way (@pxref{pack-manifest, @option{-m} option of @command{guix pack}}).  You can store the manifest under version control, share it with others so they can easily get set up, etc."
msgstr "... ou você pode passá-lo para @command{guix pack} praticamente da mesma forma (@pxref{pack-manifest, @option{-m} opção de @command{guix pack}}). Você pode armazenar o manifesto sob controle de versão, compartilhá-lo com outros para que eles possam facilmente configurar, etc."

msgid "But how do you write your first manifest? To get started, maybe you'll want to write a manifest that mirrors what you already have in a profile.  Rather than start from a blank page, @command{guix package} can generate a manifest for you (@pxref{export-manifest, @command{guix package --export-manifest}}):"
msgstr "Mas como você escreve seu primeiro manifesto? Para começar, talvez você queira escrever um manifesto que espelhe o que você já tem em um perfil. Em vez de começar do zero, @command{guix package} pode gerar um manifesto para você (@pxref{export-manifest, @command{guix package --export-manifest}}):"

msgid ""
"# Write to 'manifest.scm' a manifest corresponding to the\n"
"# default profile, ~/.guix-profile.\n"
"guix package --export-manifest > manifest.scm\n"
msgstr ""
"# Escreva em 'manifest.scm' um manifesto correspondente ao\n"
"# perfil padrão, ~/.guix-profile.\n"
"guix package --export-manifest > manifest.scm\n"

msgid "Or maybe you'll want to ``translate'' command-line arguments into a manifest.  In that case, @command{guix shell} can help (@pxref{shell-export-manifest, @command{guix shell --export-manifest}}):"
msgstr "Ou talvez você queira ``traduzir'' argumentos de linha de comando em um manifesto. Nesse caso, @command{guix shell} pode ajudar (@pxref{shell-export-manifest, @command{guix shell --export-manifest}}):"

msgid "In both cases, the @option{--export-manifest} option tries hard to generate a faithful manifest; in particular, it takes package transformation options into account (@pxref{Package Transformation Options})."
msgstr "Em ambos os casos, a opção @option{--export-manifest} tenta arduamente gerar um manifesto fiel; em particular, ela leva em consideração as opções de transformação de pacotes (@pxref{Package Transformation Options})."

msgid "Manifests are @emph{symbolic}: they refer to packages of the channels @emph{currently in use} (@pxref{Channels}).  In the example above, @code{gcc-toolchain} might refer to version 14 today, but it might refer to version 16 two years from now."
msgstr "Manifestos são @emph{simbólicos}: eles se referem a pacotes dos canais @emph{atualmente em uso} (@pxref{Channels}). No exemplo acima, @code{gcc-toolchain} pode se referir à versão 14 hoje, mas pode se referir à versão 16 daqui a dois anos."

msgid "If you want to ``pin'' your software environment to specific package versions and variants, you need an additional piece of information: the list of channel revisions in use, as returned by @command{guix describe}.  @xref{Replicating Guix}, for more information."
msgstr "Se você quiser ``fixar'' seu ambiente de software em versões e variantes de pacotes específicos, precisará de uma informação adicional: a lista de revisões de canal em uso, conforme retornado por @command{guix describe}. @xref{Replicating Guix}, para mais informações."

msgid "Once you've obtained your first manifest, perhaps you'll want to customize it.  Since your manifest is code, you now have access to all the Guix programming interfaces!"
msgstr "Depois de obter seu primeiro manifesto, talvez você queira personalizá-lo. Como seu manifesto é código, agora você tem acesso a todas as interfaces de programação Guix!"

msgid "Let's assume you want a manifest to deploy a custom variant of GDB, the GNU Debugger, that does not depend on Guile, together with another package.  Building on the example seen in the previous section (@pxref{Defining Package Variants}), you can write a manifest along these lines:"
msgstr "Vamos supor que você queira um manifesto para implantar uma variante personalizada do GDB, o GNU Debugger, que não depende do Guile, junto com outro pacote. Com base no exemplo visto na seção anterior (@pxref{Defining Package Variants}), você pode escrever um manifesto seguindo estas linhas:"

msgid ""
"(use-modules (guix packages)\n"
"             (gnu packages gdb)               ;for 'gdb'\n"
"             (gnu packages version-control))  ;for 'git'\n"
"\n"
msgstr ""
"(use-modules (guix packages)\n"
"             (gnu packages gdb)               ;para 'gdb'\n"
"             (gnu packages version-control))  ;para 'git'\n"
"\n"

msgid "Note that in this example, the manifest directly refers to the @code{gdb} and @code{git} variables, which are bound to a @code{package} object (@pxref{package Reference}), instead of calling @code{specifications->manifest} to look up packages by name as we did before.  The @code{use-modules} form at the top lets us access the core package interface (@pxref{Defining Packages}) and the modules that define @code{gdb} and @code{git} (@pxref{Package Modules}).  Seamlessly, we're weaving all this together---the possibilities are endless, unleash your creativity!"
msgstr "Observe que neste exemplo, o manifesto se refere diretamente às variáveis @code{gdb} e @code{git}, que são vinculadas a um objeto @code{package} (@pxref{package Reference}), em vez de chamar @code{specifications->manifest} para procurar pacotes por nome, como fizemos antes. O formulário @code{use-modules} no topo nos permite acessar a interface do pacote principal (@pxref{Defining Packages}) e os módulos que definem @code{gdb} e @code{git} (@pxref{Package Modules}). Sem problemas, estamos entrelaçando tudo isso — as possibilidades são infinitas, libere sua criatividade!"

msgid "The data type for manifests as well as supporting procedures are defined in the @code{(guix profiles)} module, which is automatically available to code passed to @option{-m}.  The reference follows."
msgstr "O tipo de dados para manifestos, bem como procedimentos de suporte, são definidos no módulo @code{(guix profiles)}, que está automaticamente disponível para o código passado para @option{-m}. A referência segue."

msgid "{Data Type} manifest"
msgstr "{Tipo de dados} manifest"

msgid "It currently has one field:"
msgstr "Atualmente possui um campo:"

msgid "entries"
msgstr "entries"

msgid "This must be a list of @code{manifest-entry} records---see below."
msgstr "Esta deve ser uma lista de registros @code{manifest-entry} --- veja abaixo."

msgid "{Data Type} manifest-entry"
msgstr "{Tipo de dados} manifest-entry"

msgid "Data type representing a manifest entry.  A manifest entry contains essential metadata: a name and version string, the object (usually a package) for that entry, the desired output (@pxref{Packages with Multiple Outputs}), and a number of optional pieces of information detailed below."
msgstr "Tipo de dado que representa uma entrada de manifesto. Uma entrada de manifesto contém metadados essenciais: uma string de nome e versão, o objeto (geralmente um pacote) para essa entrada, a saída desejada (@pxref{Packages with Multiple Outputs}) e uma série de informações opcionais detalhadas abaixo."

msgid "Most of the time, you won't build a manifest entry directly; instead, you will pass a package to @code{package->manifest-entry}, described below.  In some unusual cases though, you might want to create manifest entries for things that are @emph{not} packages, as in this example:"
msgstr "Na maioria das vezes, você não construirá uma entrada de manifesto diretamente; em vez disso, você passará um pacote para @code{package->manifest-entry}, descrito abaixo. Em alguns casos incomuns, no entanto, você pode querer criar entradas de manifesto para coisas que são @emph{não} pacotes, como neste exemplo:"

msgid "Name and version string for this entry."
msgstr "Nome e sequência de versão para esta entrada."

msgid "item"
msgstr "item"

msgid "A package or other file-like object (@pxref{G-Expressions, file-like objects})."
msgstr "Um pacote ou outro objeto tipo arquivo (@pxref{G-Expressions, objetos tipo arquivo})."

msgid "@code{output} (default: @code{\"out\"})"
msgstr "@code{output} (padrão: @code{\"out\"})"

msgid "Output of @code{item} to use, in case @code{item} has multiple outputs (@pxref{Packages with Multiple Outputs})."
msgstr "Saída de @code{item} a ser usada, caso @code{item} tenha múltiplas saídas (@pxref{Packages with Multiple Outputs})."

msgid "@code{dependencies} (default: @code{'()})"
msgstr "@code{dependencies} (padrão: @code{'()})"

msgid "List of manifest entries this entry depends on.  When building a profile, dependencies are added to the profile."
msgstr "Lista de entradas de manifesto das quais esta entrada depende. Ao construir um perfil, dependências são adicionadas ao perfil."

msgid "Typically, the propagated inputs of a package (@pxref{package Reference, @code{propagated-inputs}}) end up having a corresponding manifest entry in among the dependencies of the package's own manifest entry."
msgstr "Normalmente, as entradas propagadas de um pacote (@pxref{package Reference, @code{propagated-inputs}}) acabam tendo uma entrada de manifesto correspondente entre as dependências da própria entrada de manifesto do pacote."

msgid "The list of search path specifications honored by this entry (@pxref{Search Paths})."
msgstr "A lista de especificações de caminhos de pesquisa respeitadas por esta entrada (@pxref{Search Paths})."

msgid "@code{properties} (default: @code{'()})"
msgstr "@code{properties} (padrão: @code{'()})"

msgid "List of symbol/value pairs.  When building a profile, those properties get serialized."
msgstr "Lista de pares de símbolo/valor. Ao construir um perfil, essas propriedades são serializadas."

msgid "This can be used to piggyback additional metadata---e.g., the transformations applied to a package (@pxref{Package Transformation Options})."
msgstr "Isso pode ser usado para adicionar metadados adicionais, por exemplo, as transformações aplicadas a um pacote (@pxref{Package Transformation Options})."

msgid "@code{parent} (default: @code{(delay #f)})"
msgstr "@code{parent} (padrão: @code{(delay #f)})"

msgid "A promise pointing to the ``parent'' manifest entry."
msgstr "Uma promessa apontando para a entrada do manifesto ``pai''."

msgid "build system"
msgstr "sistema de compilação"

msgid "The main build system is @code{gnu-build-system}, which implements the standard build procedure for GNU and many other packages.  It is provided by the @code{(guix build-system gnu)} module."
msgstr "O principal sistema de compilação é o @code{gnu-build-system}, que implementa o processo padrão de compilação para o GNU e muitos outros pacotes.  É providenciado pelo módulo @code{(guix build-system gnu)}."

msgid "build phases"
msgstr "fases de construção"

msgid "This build system supports a number of keyword arguments, which can be passed @i{via} the @code{arguments} field of a package.  Here are some of the main parameters:"
msgstr "Esta sistema de compilação suporta um número de palavras-chave como argumentos, os quais podems er passados @i{via} o campo @code{arguments} de um pacote.  Veja alguns dos principais parâmetros:"

msgid "#:substitutable?"
msgstr "#:substituível?"

msgid "Most other build systems support these keyword arguments."
msgstr "Vários outros sistemas de compilação suportam tais argumentos em palavras-chave."

msgid "The build system assumes that packages install their public interface (header) files to the subdirectory @file{include} of the @code{out} output and their libraries to the subdirectory @file{lib} the @code{out} output."
msgstr "O sistema de compilação presume que os pacotes instalam seu prório arquivo (header) de interface pública no subdiretório @file{include} da saída @code{out} bem como suas próprias bibliotecas no subdirectório @file{lib} da saída @code{out}."

msgid "It's also assumed that the union of all the dependencies of a package has no conflicting files."
msgstr "Também é presumido que a união de todas as dependências de um pacote não possuem arquivos conflitantes."

msgid "Examples:"
msgstr "Exemplos:"

msgid "build"
msgstr "build"

msgid "check"
msgstr "marcar"

msgid "install"
msgstr "install"

msgid "bootstrap"
msgstr "bootstrap"

msgid "configure"
msgstr "configure"

msgid "This variable is exported by @code{(guix build-system texlive)}.  It is used to build TeX packages in batch mode with a specified engine.  The build system sets the @env{TEXINPUTS} variable to find all TeX source files in the inputs."
msgstr "Esta variável é exportada pelo @code{(guix build-system texlive)}.  É usado para compilar os pacotes TeX no modo de lote com um moter especificado.  O sistema de compilação configura a variável @env{TEXINPUTS} para encontrar todos os arquivos de fonte TeX na entrada."

msgid "Tip"
msgstr "Dica"

msgid "{Data Type} search-path-specification"
msgstr "{Tipo de dados} search-path-specification"

msgid "files"
msgstr "files"

msgid "store items"
msgstr "itens do armazém"

msgid "unix"
msgstr "unix"

msgid "references"
msgstr "references"

msgid "cross compilation"
msgstr "compilação cruzada"

msgid "#$@var{obj}:@var{output}"
msgstr "#$@var{obj}:@var{saída}"

msgid "(ungexp @var{obj} @var{output})"
msgstr "(ungexp @var{obj} @var{saída})"

msgid "#+@var{obj}:output"
msgstr "#+@var{obj}:output"

msgid "#$output[:@var{output}]"
msgstr "#$output[:@var{saída}]"

msgid "(ungexp output [@var{output}])"
msgstr "(ungexp output [@var{saída}])"

msgid "Invoking @command{guix repl}"
msgstr "Invocando @command{guix repl}"

msgid "-t @var{type}"
msgstr "-t @var{tipo}"

msgid "-L @var{directory}"
msgstr "-L @var{diretório}"

msgid "--keep-failed"
msgstr "--keep-failed"

msgid "--keep-going"
msgstr "--keep-going"

msgid "fallback-option"
msgstr "fallback-option"

msgid "--fallback"
msgstr "--fallback"

msgid "--no-grafts"
msgstr "--no-grafts"

msgid "--rounds=@var{n}"
msgstr "--rounds=@var{n}"

msgid "package transformation"
msgstr "transformação de pacotes"

msgid "package variants, transformation"
msgstr "variantes de pacote, transformação"

msgid "--with-source=@var{source}"
msgstr "--with-source=@var{fonte}"

msgid "--with-source=@var{package}=@var{source}"
msgstr "--with-source=@var{pacote}=@var{fonte}"

msgid "--with-input=@var{package}=@var{replacement}"
msgstr "--with-input=@var{pacote}=@var{substituto}"

msgid "--with-git-url=@var{package}=@var{url}"
msgstr "--with-git-url=@var{pacote}=@var{url}"

msgid "continuous integration"
msgstr "integração contínua"

msgid "--with-branch=@var{package}=@var{branch}"
msgstr "--with-branch=@var{pacote}=@var{ramo}"

msgid "guix build --with-branch=guile-sqlite3=master cuirass\n"
msgstr "guix build --with-branch=guile-sqlite3=master cuirass\n"

msgid "--with-commit=@var{package}=@var{commit}"
msgstr "--with-commit=@var{pacote}=@var{commit}"

msgid "package"
msgstr "package"

msgid "all"
msgstr "all"

msgid "build-check"
msgstr "build-check"

msgid "determinism, checking"
msgstr "determinismo, verificação"

msgid "reproducibility, checking"
msgstr "reprodutibilidade, verificação"

msgid "Invoking @command{guix edit}"
msgstr "Invocando @command{guix edit}"

msgid "Invoking @command{guix download}"
msgstr "Invocando @command{guix download}"

msgid "--output=@var{file}"
msgstr "--output=@var{arquivo}"

msgid "-o @var{file}"
msgstr "-o @var{arquivo}"

msgid "Invoking @command{guix hash}"
msgstr "Invocando @command{guix hash}"

msgid "none"
msgstr "none"

msgid "git"
msgstr "git"

msgid "-x"
msgstr "-x"

msgid "pypi"
msgstr "pypi"

msgid "cran"
msgstr "cran"

msgid "CRAN"
msgstr "CRAN"

msgid "TeX Live"
msgstr "TeX Live"

msgid "-s"
msgstr "-s"

msgid "--lts-version=@var{version}"
msgstr "--lts-version=@var{versão}"

msgid "-l @var{version}"
msgstr "-l @var{versão}"

msgid "elpa"
msgstr "elpa"

msgid "OCaml"
msgstr "OCaml"

msgid "Composer"
msgstr "Composer"

msgid "PHP"
msgstr "PHP"

msgid "Invoking @command{guix refresh}"
msgstr "Invocando @command{guix refresh}"

msgid "guix refresh -l -e '(@@@@ (gnu packages commencement) glibc-final)'\n"
msgstr "guix refresh -l -e '(@@@@ (gnu packages commencement) glibc-final)'\n"

msgid "gnome"
msgstr "gnome"

msgid "--list-transitive"
msgstr "--list-transitive"

msgid "always"
msgstr "always"

msgid "never"
msgstr "never"

msgid "guix style [@var{options}] @var{package}@dots{}\n"
msgstr "guix style [@var{options}] @var{package}@dots{}\n"

msgid "format"
msgstr "format"

msgid "inputs"
msgstr "inputs"

msgid "Invoking @command{guix lint}"
msgstr "Invocando @command{guix lint}"

msgid "profile-collisions"
msgstr "profile-collisions"

msgid "guix lint @var{options} @var{package}@dots{}\n"
msgstr "guix lint @var{opções} @var{pacote}@dots{}\n"

msgid "--list-checkers"
msgstr "--list-checkers"

msgid "--checkers"
msgstr "--checkers"

msgid "-c"
msgstr "-c"

msgid "Invoking @command{guix size}"
msgstr "Invocando @command{guix size}"

msgid "size"
msgstr "size"

msgid "self"
msgstr "self"

msgid "--map-file=@var{file}"
msgstr "--map-file=@var{arquivo}"

msgid "Invoking @command{guix graph}"
msgstr "Invocando @command{guix graph}"

msgid "guix graph"
msgstr "guix graph"

msgid "guix graph @var{options} @var{package}@dots{}\n"
msgstr "guix graph @var{opções} @var{pacote}@dots{}\n"

msgid "List the supported graph types."
msgstr "Lista os tipos de grafos disponíveis."

msgid "--list-backends"
msgstr "--list-backends"

msgid "List the supported graph backends."
msgstr "Lista os backends de grafos disponíveis."

msgid "guix graph -e '(@@@@ (gnu packages commencement) gnu-make-final)'\n"
msgstr "guix graph -e '(@@@@ (gnu packages commencement) gnu-make-final)'\n"

msgid "Invoking @command{guix publish}"
msgstr "Invocando @command{guix publish}"

msgid "--port=@var{port}"
msgstr "--port=@var{porta}"

msgid "-p @var{port}"
msgstr "-p @var{porta}"

msgid "Listen for HTTP requests on @var{port}."
msgstr "Ouve requisições HTTP na @var{porta}."

msgid "--workers=@var{N}"
msgstr "--workers=@var{N}"

msgid "-r [@var{port}]"
msgstr "-r [@var{porta}]"

msgid "If your host distro uses the Upstart init system:"
msgstr "Se sua distro hospedeira usa o sistema init Upstart:"

msgid "Invoking @command{guix challenge}"
msgstr "Invocando @command{guix challenge}"

msgid ""
"@dots{}\n"
"\n"
msgstr ""
"@dots{}\n"
"\n"

msgid "command"
msgstr "comando"

msgid "--verbose"
msgstr "--verbose"

msgid "Invoking @command{guix copy}"
msgstr "Invocando @command{guix copy}"

msgid "Invoking @command{guix container}"
msgstr "Invocando @command{guix container}"

msgid "guix container exec 9001 /run/current-system/profile/bin/bash --login\n"
msgstr "guix container exec 9001 /run/current-system/profile/bin/bash --login\n"

msgid "Invoking @command{guix weather}"
msgstr "Invocando @command{guix weather}"

msgid "--coverage[=@var{count}]"
msgstr "--coverage[=@var{contagem}]"

msgid "-c [@var{count}]"
msgstr "-c [@var{contagem}]"

msgid "Invoking @command{guix processes}"
msgstr "Invocando @command{guix processes}"

msgid "foreign architectures"
msgstr "arquiteturas estrangeiras"

msgid "system configuration"
msgstr "configuração do sistema"

msgid "One of the advantages of putting all the system configuration under the control of Guix is that it supports transactional system upgrades, and makes it possible to roll back to a previous system instantiation, should something go wrong with the new one (@pxref{Features}).  Another advantage is that it makes it easy to replicate the exact same configuration across different machines, or at different points in time, without having to resort to additional administration tools layered on top of the own tools of the system."
msgstr "Uma das vantages de colocar todas as configurações do sistema sob controle do Guix é que ele permite atualizações transacionais do sistema, o que torna possível o retrocesso a uma instanciação anterior do sistema, caso algo de errado com a nova (@pxref{Features}).  Outra vantagem é que ele facilita a replicação da mesma configuração em máquinas diferentes, ou em momentos diferentesm sem ter que passar por outras ferramentas de administração adicionais por cima das ferramentas do sistema."

msgid "operating-system"
msgstr "operating-system"

msgid "os-config-bare-bones.texi"
msgstr "os-config-bare-bones.texi"

msgid "Bootloader"
msgstr "Carregador de inicialização"

msgid "System Services"
msgstr "Serviços do sistema"

msgid "services"
msgstr "services"

msgid "auto-login to TTY"
msgstr "auto-login to TTY"

msgid ""
"(operating-system\n"
"  ;; @dots{}\n"
"  (services %my-services))\n"
msgstr ""
"(operating-system\n"
"  ;; @dots{}\n"
"  (services %my-services))\n"

msgid "os-config-desktop.texi"
msgstr "os-config-desktop.texi"

msgid "A graphical system with a choice of lightweight window managers instead of full-blown desktop environments would look like this:"
msgstr "Um sistema gráfico com uma escolha de gerenciadores de janelas leves em vez de ambientes de desktop completos teria a seguinte aparência:"

msgid "os-config-lightweight-desktop.texi"
msgstr "os-config-lightweight-desktop.texi"

msgid "This example refers to the @file{/boot/efi} file system by its UUID, @code{1234-ABCD}.  Replace this UUID with the right UUID on your system, as returned by the @command{blkid} command."
msgstr "Este exemplo faz referência ao sistema de arquivos @file{/boot/efi} por seu UUID, @code{1234-ABCD}. Substitua esse UUID pelo UUID correto no seu sistema, conforme retornado pelo comando @command{blkid}."

msgid "{Data Type} operating-system"
msgstr "{Tipo de dados} operating-system"

msgid "bootloader"
msgstr "bootloader"

msgid "label"
msgstr "label"

msgid "@code{keyboard-layout} (default: @code{#f})"
msgstr "@code{keyboard-layout} (padrão: @code{#f})"

msgid "file-systems"
msgstr "file-systems"

msgid "{Data Type} file-system"
msgstr "{Tipo de dados} file-system"

msgid "type"
msgstr "tipo"

msgid "mount-point"
msgstr "mount-point"

msgid "device"
msgstr "device"

msgid "uuid"
msgstr "uuid"

msgid "@code{options} (default: @code{#f})"
msgstr "@code{options} (padrão: @code{#f})"

msgid "@code{mount?} (default: @code{#t})"
msgstr "@code{mount?} (padrão: @code{#t})"

msgid "@code{check?} (default: @code{#t})"
msgstr "@code{check?} (padrão: @code{#t})"

msgid "{Data Type} mapped-device"
msgstr "{Tipo de dados} mapped-device"

msgid "target"
msgstr "target"

msgid "targets"
msgstr "targets"

msgid "LUKS"
msgstr "LUKS"

msgid "{Data Type} swap-space"
msgstr "{Tipo de dados} swap-space"

msgid "users"
msgstr "usuários"

msgid "{Data Type} user-account"
msgstr "{Tipo de dados} user-account"

msgid "group"
msgstr "group"

msgid "@code{uid} (default: @code{#f})"
msgstr "@code{uid} (padrão: @code{#f})"

msgid "home-directory"
msgstr "home-directory"

msgid "@code{system?} (default: @code{#f})"
msgstr "@code{system?} (padrão: @code{#f})"

msgid "user-account-password"
msgstr "user-account-password"

msgid "(user-group (name \"students\"))\n"
msgstr "(user-group (name \"students\"))\n"

msgid "{Data Type} user-group"
msgstr "{Tipo de dados} user-group"

msgid "@code{id} (default: @code{#f})"
msgstr "@code{id} (default: @code{#f})"

msgid "keyboard layout, definition"
msgstr "disposição do teclado, definição"

msgid "XKB, keyboard layouts"
msgstr "XKB, disposições do teclado"

msgid "keyboard layout, configuration"
msgstr "disposição do teclado, configuração"

msgid "loadkeys fr-bepo\n"
msgstr "loadkeys fr-bepo\n"

msgid "locale"
msgstr "localidade"

msgid "{Data Type} locale-definition"
msgstr "{Tipo de dados} locale-definition"

msgid "system services"
msgstr "serviços de sistema"

msgid "/usr/bin/env"
msgstr "/usr/bin/env"

msgid "{Data Type} login-configuration"
msgstr "{Tipo de dados} login-configuration"

msgid "{Data Type} mingetty-configuration"
msgstr "{Tipo de dados} mingetty-configuration"

msgid "@code{delay} (default: @code{#f})"
msgstr "@code{delay} (default: @code{#f})"

msgid "@code{nice} (default: @code{#f})"
msgstr "@code{nice} (default: @code{#f})"

msgid "{Data Type} agetty-configuration"
msgstr "{Tipo de dados} agetty-configuration"

msgid "@code{term} (default: @code{#f})"
msgstr "@code{term} (default: @code{#f})"

msgid "@code{no-reset?} (default: @code{#f})"
msgstr "@code{no-reset?} (default: @code{#f})"

msgid "@code{host} (default: @code{#f})"
msgstr "@code{host} (default: @code{#f})"

msgid "@code{remote?} (default: @code{#f})"
msgstr "@code{remote?} (padrão: @code{#f})"

msgid "@code{no-issue?} (default: @code{#f})"
msgstr "@code{no-issue?} (padrão: @code{#f})"

msgid "@code{no-clear?} (default: @code{#f})"
msgstr "@code{no-clear?} (padrão: @code{#f})"

msgid "@code{no-newline?} (default: @code{#f})"
msgstr "@code{no-newline?} (padrão: @code{#f})"

msgid "@code{chroot} (default: @code{#f})"
msgstr "@code{chroot} (default: @code{#f})"

msgid "@code{hangup?} (default: @code{#f})"
msgstr "@code{hangup?} (padrão: @code{#f})"

msgid "@code{no-hints?} (default: @code{#f})"
msgstr "@code{no-hints?} (padrão: @code{#f})"

msgid "@code{no-hostname?} (default: @code{#f})"
msgstr "@code{no-hostname?} (default: @code{#f})"

msgid "@code{chdir} (default: @code{#f})"
msgstr "@code{chdir} (default: @code{#f})"

msgid "{Data Type} kmscon-configuration"
msgstr "{Tipo de dados} kmscon-configuration"

msgid "{Data Type} nscd-configuration"
msgstr "{Tipo de dados} nscd-configuration"

msgid "@code{log-file} (default: @code{#f})"
msgstr "@code{log-file} (default: @code{#f})"

msgid "{Data Type} nscd-cache"
msgstr "{Tipo de dados} nscd-cache"

msgid "@code{persistent?} (default: @code{#t})"
msgstr "@code{persistent?} (padrão: @code{#t})"

msgid "@code{shared?} (default: @code{#t})"
msgstr "@code{shared?} (padrão: @code{#t})"

msgid "{Data Type} syslog-configuration"
msgstr "{Tipo de dados} syslog-configuration"

msgid "guix-configuration-type"
msgstr "guix-configuration-type"

msgid "{Data Type} guix-configuration"
msgstr "{Tipo de dados} guix-configuration"

msgid "@code{guix} (default: @var{guix})"
msgstr "@code{guix} (default: @var{guix})"

msgid "@code{tmpdir} (default: @code{#f})"
msgstr "@code{tmpdir} (default: @code{#f})"

msgid "{Data Type} guix-extension"
msgstr "{Tipo de dados} guix-extension"

msgid "{Data Type} udev-configuration"
msgstr "{Tipo de dados} udev-configuration"

msgid "mouse"
msgstr "mouse"

msgid "{Data Type} gpm-configuration"
msgstr "{Tipo de dados} gpm-configuration"

msgid "The GPM package to use."
msgstr "O pacote GPM a ser usado."

msgid "guix-publish-service-type"
msgstr "guix-publish-service-type"

msgid "{Data Type} guix-publish-configuration"
msgstr "{Tipo de dados} guix-publish-configuration"

msgid "@code{port} (default: @code{80})"
msgstr "@code{port} (padrão: @code{80})"

msgid "@code{cache} (default: @code{#f})"
msgstr "@code{cache} (default: @code{#f})"

msgid "@code{workers} (default: @code{#f})"
msgstr "@code{workers} (default: @code{#f})"

msgid "@code{ttl} (default: @code{#f})"
msgstr "@code{ttl} (default: @code{#f})"

msgid "{Data Type} rngd-configuration"
msgstr "{Tipo de dados} rngd-configuration"

msgid "{Data Type} greetd-configuration"
msgstr "{Tipo de dados} greetd-configuration"

msgid "{Data Type} greetd-terminal-configuration"
msgstr "{Tipo de dados} greetd-terminal-configuration"

msgid "{Data Type} greetd-agreety-session"
msgstr "{Tipo de dados} greetd-agreety-session"

msgid "{Data Type} greetd-wlgreet-sway-session"
msgstr "{Tipo de dados} greetd-wlgreet-sway-session"

msgid "{Data Type} mcron-configuration"
msgstr "{Tipo de dados} mcron-configuration"

msgid "{Data Type} log-cleanup-configuration"
msgstr "{Tipo de dados} log-cleanup-configuration"

msgid "directory"
msgstr "directory"

msgid "{Data Type} anonip-configuration"
msgstr "{Tipo de dados} anonip-configuration"

msgid "This data type represents the configuration of anonip.  It has the following parameters:"
msgstr "Este tipo de dado representa a configuração do anonip. Ele possui os seguintes parâmetros:"

msgid "input"
msgstr "input"

msgid "output"
msgstr "output"

msgid "debug?"
msgstr "debug?"

msgid "column"
msgstr "column"

msgid "{Data Type} static-networking"
msgstr "{Tipo de dados} static-networking"

msgid "addresses"
msgstr "addresses"

msgid "{Data Type} network-address"
msgstr "{Tipo de dados} network-address"

msgid "value"
msgstr "value"

msgid "ipv6?"
msgstr "ipv6?"

msgid "{Data Type} network-route"
msgstr "{Tipo de dados} network-route"

msgid "destination"
msgstr "destination"

msgid "@code{device} (default: @code{#f})"
msgstr "@code{device} (default: @code{#f})"

msgid "{Data Type} network-link"
msgstr "{Tipo de dados} network-link"

msgid "{Data Type} dhcp-client-configuration"
msgstr "{Tipo de dados} dhcp-client-configuration"

msgid "NetworkManager"
msgstr "NetworkManager"

msgid "{Data Type} network-manager-configuration"
msgstr "{Tipo de dados} network-manager-configuration"

msgid "{Data Type} connman-configuration"
msgstr "{Tipo de dados} connman-configuration"

msgid "{Data Type} connman-general-configuration"
msgstr "{Tipo de dados} connman-general-configuration"

msgid "{Data Type} wpa-supplicant-configuration"
msgstr "{Tipo de dados} wpa-supplicant-configuration"

msgid "@code{dbus?} (default: @code{#t})"
msgstr "@code{dbus?} (padrão: @code{#t})"

msgid "{Data Type} modem-manager-configuration"
msgstr "{Tipo de dados} modem-manager-configuration"

msgid "{Data Type} usb-modeswitch-configuration"
msgstr "{Tipo de dados} usb-modeswitch-configuration"

msgid "{Data Type} dhcpd-configuration"
msgstr "{Tipo de dados} dhcpd-configuration"

msgid "{Data Type} hostapd-configuration"
msgstr "{Tipo de dados} hostapd-configuration"

msgid "{Data Type} iptables-configuration"
msgstr "{Tipo de dados} iptables-configuration"

msgid "{Data Type} nftables-configuration"
msgstr "{Tipo de dados} nftables-configuration"

msgid "{Data Type} ntp-configuration"
msgstr "{Tipo de dados} ntp-configuration"

msgid "{Data Type} ntp-server"
msgstr "{Tipo de dados} ntp-server"

msgid "address"
msgstr "address"

msgid "options"
msgstr "options"

msgid "{Data Type} openntpd-configuration"
msgstr "{Tipo de dados} openntpd-configuration"

msgid "{Data Type} inetd-configuration"
msgstr "{Tipo de dados} inetd-configuration"

msgid "{Data Type} inetd-entry"
msgstr "{Tipo de dados} inetd-entry"

msgid "@code{node} (default: @code{#f})"
msgstr "@code{node} (default: @code{#f})"

msgid "protocol"
msgstr "protocol"

msgid "@code{wait?} (default: @code{#t})"
msgstr "@code{wait?} (padrão: @code{#t})"

msgid "{Data Type} opendht-configuration"
msgstr "{Tipo de dados} opendht-configuration"

msgid "{Data Type} tor-configuration"
msgstr "{Tipo de dados} tor-configuration"

msgid "@code{tor} (default: @code{tor})"
msgstr "@code{tor} (default: @code{tor})"

msgid "{Data Type} tor-onion-service-configuration"
msgstr "{Tipo de dados} tor-onion-service-configuration"

msgid "{Data Type} tor-transport-plugin"
msgstr "{Tipo de dados} tor-transport-plugin"

msgid "{Data Type} rsync-configuration"
msgstr "{Tipo de dados} rsync-configuration"

msgid "{Data Type} rsync-module"
msgstr "{Tipo de dados} rsync-module"

msgid "{Data Type} syncthing-configuration"
msgstr "{Tipo de dados} syncthing-configuration"

msgid "path"
msgstr "path"

msgid "{Data Type} openssh-configuration"
msgstr "{Tipo de dados} openssh-configuration"

msgid "@code{x11-forwarding?} (default: @code{#f})"
msgstr "@code{x11-forwarding?} (padrão: @code{#f})"

msgid "@code{allow-agent-forwarding?} (default: @code{#t})"
msgstr "@code{allow-agent-forwarding?} (padrão: @code{#t})"

msgid "@code{allow-tcp-forwarding?} (default: @code{#t})"
msgstr "@code{allow-tcp-forwarding?} (padrão: @code{#t})"

msgid "@code{gateway-ports?} (default: @code{#f})"
msgstr "@code{gateway-ports?} (padrão: @code{#f})"

msgid "@code{log-level} (default: @code{'info})"
msgstr "@code{log-level} (default: @code{'info})"

msgid "{Data Type} dropbear-configuration"
msgstr "{Tipo de dados} dropbear-configuration"

msgid "@code{syslog-output?} (default: @code{#t})"
msgstr "@code{syslog-output?} (padrão: @code{#t})"

msgid "{Data Type} autossh-configuration"
msgstr "{Tipo de dados} autossh-configuration"

msgid "@code{port} (default @code{\"0\"})"
msgstr "@code{port} (padrão @code{\"0\"})"

msgid "{Data Type} webssh-configuration"
msgstr "{Tipo de dados} webssh-configuration"

msgid "@code{port} (default: @var{8888})"
msgstr "@code{port} (padrão: @var{8888})"

msgid "{Data Type} avahi-configuration"
msgstr "{Tipo de dados} avahi-configuration"

msgid "@code{host-name} (default: @code{#f})"
msgstr "@code{host-name} (padrão: @code{#f})"

msgid "@code{publish?} (default: @code{#t})"
msgstr "@code{publish?} (padrão: @code{#t})"

msgid "@code{publish-workstation?} (default: @code{#t})"
msgstr "@code{publish-workstation?} (padrão: @code{#t})"

msgid "avahi-browse _workstation._tcp\n"
msgstr "avahi-browse _workstation._tcp\n"

msgid "@code{wide-area?} (default: @code{#f})"
msgstr "@code{wide-area?} (padrão: @code{#f})"

msgid "@code{ipv4?} (default: @code{#t})"
msgstr "@code{ipv4?} (default: @code{#t})"

msgid "@code{ipv6?} (default: @code{#t})"
msgstr "@code{ipv6?} (default: @code{#t})"

msgid "{Data Type} openvswitch-configuration"
msgstr "{Tipo de dados} openvswitch-configuration"

msgid "{Data Type} pagekite-configuration"
msgstr "{Tipo de dados} pagekite-configuration"

msgid "{Data Type} yggdrasil-configuration"
msgstr "{Tipo de dados} yggdrasil-configuration"

msgid "{Data Type} ipfs-configuration"
msgstr "{Tipo de dados} ipfs-configuration"

msgid "(service unattended-upgrade-service-type)\n"
msgstr "(service unattended-upgrade-service-type)\n"

msgid "{Data Type} unattended-upgrade-configuration"
msgstr "{Tipo de dados} unattended-upgrade-configuration"

msgid "window manager"
msgstr "gerenciadores de janelas"

msgid "{Data Type} gdm-configuration"
msgstr "{Tipo de dados} gdm-configuration"

msgid "@code{debug?} (default: @code{#f})"
msgstr "@code{debug?} (default: @code{#f})"

msgid "@code{gdm} (default: @code{gdm})"
msgstr "@code{gdm} (default: @code{gdm})"

msgid "{Data Type} slim-configuration"
msgstr "{Tipo de dados} slim-configuration"

msgid "{Data Type} sddm-configuration"
msgstr "{Tipo de dados} sddm-configuration"

msgid "{Data Type} lightdm-configuration"
msgstr "{Tipo de dados} lightdm-configuration"

msgid "{Data Type} lightdm-gtk-greeter-configuration"
msgstr "{Tipo de dados} lightdm-gtk-greeter-configuration"

msgid "{Data Type} lightdm-seat-configuration"
msgstr "{Tipo de dados} lightdm-seat-configuration"

msgid "{Data Type} xorg-configuration"
msgstr "{Tipo de dados} xorg-configuration"

msgid "keyboard layout, for Xorg"
msgstr "disposição do teclado, para Xorg"

msgid "{Data Type} screen-locker-configuration"
msgstr "{Tipo de dados} screen-locker-configuration"

msgid "browse"
msgstr "browse"

msgid "config"
msgstr "config"

msgid "listen"
msgstr "listen"

msgid "log"
msgstr "log"

msgid "permissions"
msgstr "permissions"

msgid "{Data Type} gnome-desktop-configuration"
msgstr "{Tipo de dados} gnome-desktop-configuration"

msgid "{Data Type} plasma-desktop-configuration"
msgstr "{Tipo de dados} plasma-desktop-configuration"

msgid "{Data Type} xfce-desktop-configuration"
msgstr "{Tipo de dados} xfce-desktop-configuration"

msgid "@code{xfce} (default: @code{xfce})"
msgstr "@code{xfce} (default: @code{xfce})"

msgid "{Data Type} mate-desktop-configuration"
msgstr "{Tipo de dados} mate-desktop-configuration"

msgid "{Data Type} lxqt-desktop-configuration"
msgstr "{Tipo de dados} lxqt-desktop-configuration"

msgid "{Data Type} sugar-desktop-configuration"
msgstr "{Tipo de dados} sugar-desktop-configuration"

msgid "{Data Type} enlightenment-desktop-service-configuration"
msgstr "{Tipo de dados} enlightenment-desktop-service-configuration"

msgid "{Data Type} dbus-configuration"
msgstr "{Tipo de dados} dbus-configuration"

msgid "{Data Type} elogind-configuration"
msgstr "{Tipo de dados} elogind-configuration"

msgid "{Data Type} upower-configuration"
msgstr "{Tipo de dados} upower-configuration"

msgid "@code{upower} (default: @var{upower})"
msgstr "@code{upower} (default: @var{upower})"

msgid "@code{watts-up-pro?} (default: @code{#f})"
msgstr "@code{watts-up-pro?} (padrão: @code{#f})"

msgid "@code{poll-batteries?} (default: @code{#t})"
msgstr "@code{poll-batteries?} (padrão: @code{#t})"

msgid "@code{ignore-lid?} (default: @code{#f})"
msgstr "@code{ignore-lid?} (padrão: @code{#f})"

msgid "{Data Type} udisks-configuration"
msgstr "{Tipo de dados} udisks-configuration"

msgid "{Data Type} gvfs-configuration"
msgstr "{Tipo de dados} gvfs-configuration"

msgid "{Data Type} bluetooth-configuration"
msgstr "{Tipo de dados} bluetooth-configuration"

msgid "@code{fast-connectable?} (default: @code{#f})"
msgstr "@code{fast-connectable?} (padrão: @code{#f})"

msgid "{Data Type} gnome-keyring-configuration"
msgstr "{Tipo de dados} gnome-keyring-configuration"

msgid "{Data Type} seatd-configuration"
msgstr "{Tipo de dados} seatd-configuration"

msgid "{Data Type} alsa-configuration"
msgstr "{Tipo de dados} alsa-configuration"

msgid "{Data Type} pulseaudio-configuration"
msgstr "{Tipo de dados} pulseaudio-configuration"

msgid "{Data Type} file-database-configuration"
msgstr "{Tipo de dados} file-database-configuration"

msgid "{Data Type} package-database-configuration"
msgstr "{Tipo de dados} package-database-configuration"

msgid "PostgreSQL"
msgstr "PostgreSQL"

msgid "{Data Type} postgresql-configuration"
msgstr "{Tipo de dados} postgresql-configuration"

msgid "@code{port} (default: @code{5432})"
msgstr "@code{port} (padrão: @code{5432})"

msgid "{Data Type} postgresql-config-file"
msgstr "{Tipo de dados} postgresql-config-file"

msgid "{Data Type} postgresql-role"
msgstr "{Tipo de dados} postgresql-role"

msgid "{Data Type} postgresql-role-configuration"
msgstr "{Tipo de dados} postgresql-role-configuration"

msgid "{Data Type} mysql-configuration"
msgstr "{Tipo de dados} mysql-configuration"

msgid "@code{port} (default: @code{3306})"
msgstr "@code{port} (padrão: @code{3306})"

msgid "{Data Type} memcached-configuration"
msgstr "{Tipo de dados} memcached-configuration"

msgid "{Data Type} redis-configuration"
msgstr "{Tipo de dados} redis-configuration"

msgid "email"
msgstr "e-mail"

msgid "Message-ID"
msgstr "Mensagem-ID"

msgid "Subject"
msgstr "Assunto"

msgid "username"
msgstr "nome de usuário"

msgid "%d"
msgstr "%d"

msgid "home directory"
msgstr "diretório pessoal"

msgid "recipient"
msgstr "destinatário"

msgid "{Data Type} opensmtpd-configuration"
msgstr "{Tipo de dados} opensmtpd-configuration"

msgid "SMTP"
msgstr "SMTP"

msgid "{Data Type} exim-configuration"
msgstr "{Tipo de dados} exim-configuration"

msgid "IMAP"
msgstr "IMAP"

msgid "POP"
msgstr "POP"

msgid "{Data Type} imap4d-configuration"
msgstr "{Tipo de dados} imap4d-configuration"

msgid "{Data Type} radicale-configuration"
msgstr "{Tipo de dados} radicale-configuration"

msgid "{Data Type} radicale-auth-configuration"
msgstr "{Tipo de dados} radicale-auth-configuration"

msgid "{Data Type} radicale-encoding-configuration"
msgstr "{Tipo de dados} radicale-encoding-configuration"

msgid "{Data Type} radicale-logging-configuration"
msgstr "{Tipo de dados} radicale-logging-configuration"

msgid "{Data Type} radicale-rights-configuration"
msgstr "{Tipo de dados} radicale-rights-configuration"

msgid "{Data Type} radicale-server-configuration"
msgstr "{Tipo de dados} radicale-server-configuration"

msgid "{Data Type} radicale-storage-configuration"
msgstr "{Tipo de dados} radicale-storage-configuration"

msgid "{Data Type} rspamd-configuration"
msgstr "{Tipo de dados} rspamd-configuration"

msgid "XMPP"
msgstr "XMPP"

msgid "{Data Type} bitlbee-configuration"
msgstr "{Tipo de dados} bitlbee-configuration"

msgid "@code{port} (default: @code{6667})"
msgstr "@code{port} (padrão: @code{6667})"

msgid "{Data Type} quassel-configuration"
msgstr "{Tipo de dados} quassel-configuration"

msgid "@code{port} (default: @code{4242})"
msgstr "@code{port} (padrão: @code{4242})"

msgid "telephony, services"
msgstr "telefonia, serviços"

msgid "{Data Type} jami-configuration"
msgstr "{Tipo de dados} jami-configuration"

msgid "{Data Type} jami-account"
msgstr "{Tipo de dados} jami-account"

msgid "{Data Type} mumble-server-configuration"
msgstr "{Tipo de dados} mumble-server-configuration"

msgid "@code{port} (default: @code{64738})"
msgstr "@code{port} (padrão: @code{64738})"

msgid "@code{remember-channel?} (default: @code{#f})"
msgstr "@code{remember-channel?} (padrão: @code{#f})"

msgid "@code{bonjour?} (default: @code{#f})"
msgstr "@code{bonjour?} (padrão: @code{#f})"

msgid "@code{file} (default: @code{#f})"
msgstr "@code{file} (padrão: @code{#f})"

msgid "{Data Type} mumble-server-public-registration-configuration"
msgstr "{Tipo de dados} mumble-server-public-registration-configuration"

msgid "password"
msgstr "password"

msgid "@code{hostname} (default: @code{#f})"
msgstr "@code{hostname} (padrão: @code{#f})"

msgid "{Data Type} transmission-daemon-configuration"
msgstr "{Tipo de dados} transmission-daemon-configuration"

msgid "{Data Type} darkstat-configuration"
msgstr "{Tipo de dados} darkstat-configuration"

msgid "interface"
msgstr "interface"

msgid "@code{port} (default: @code{\"667\"})"
msgstr "@code{port} (padrão: @code{\"667\"})"

msgid "{Data Type} prometheus-node-exporter-configuration"
msgstr "{Tipo de dados} prometheus-node-exporter-configuration"

msgid "{Data Type} vnstat-configuration"
msgstr "{Tipo de dados} vnstat-configuration"

msgid "{Data Type} zabbix-server-configuration"
msgstr "{Tipo de dados} zabbix-server-configuration"

msgid "{Data Type} zabbix-agent-configuration"
msgstr "{Tipo de dados} zabbix-agent-configuration"

msgid "{Data Type} zabbix-front-end-configuration"
msgstr "{Tipo de dados} zabbix-front-end-configuration"

msgid "{Data Type} krb5-realm"
msgstr "{Tipo de dados} krb5-realm"

msgid "{Data Type} krb5-configuration"
msgstr "{Tipo de dados} krb5-configuration"

msgid "{Data Type} pam-krb5-configuration"
msgstr "{Tipo de dados} pam-krb5-configuration"

msgid "LDAP"
msgstr "LDAP"

msgid "{Data Type} directory-server-instance-configuration"
msgstr "{Tipo de dados} directory-server-instance-configuration"

msgid "{Data Type} slapd-configuration"
msgstr "{Tipo de dados} slapd-configuration"

msgid "{Data Type} backend-userroot-configuration"
msgstr "{Tipo de dados} backend-userroot-configuration"

msgid "web"
msgstr "web"

msgid "HTTP"
msgstr "HTTP"

msgid "{Data Type} httpd-configuration"
msgstr "{Tipo de dados} httpd-configuration"

msgid "{Data Type} httpd-module"
msgstr "{Tipo de dados} httpd-module"

msgid "{Data Type} httpd-config-file"
msgstr "{Tipo de dados} httpd-config-file"

msgid "{Data Type} httpd-virtualhost"
msgstr "{Tipo de dados} httpd-virtualhost"

msgid "contents"
msgstr "contents"

msgid "{Data Type} nginx-configuration"
msgstr "{Tipo de dados} nginx-configuration"

msgid "nginx-server-configuration"
msgstr "nginx-server-configuration"

msgid "{Data Type} nginx-server-configuration"
msgstr "{Tipo de dados} nginx-server-configuration"

msgid "{Data Type} nginx-upstream-configuration"
msgstr "{Tipo de dados} nginx-upstream-configuration"

msgid "servers"
msgstr "servers"

msgid "{Data Type} nginx-location-configuration"
msgstr "{Tipo de dados} nginx-location-configuration"

msgid "nginx-location-configuration body"
msgstr "nginx-location-configuration body"

msgid "body"
msgstr "body"

msgid "{Data Type} nginx-named-location-configuration"
msgstr "{Tipo de dados} nginx-named-location-configuration"

msgid "{Data Type} varnish-configuration"
msgstr "{Tipo de dados} varnish-configuration"

msgid "{Data Type} whoogle-configuration"
msgstr "{Tipo de dados} whoogle-configuration"

msgid "@code{port} (default: @code{5000})"
msgstr "@code{port} (padrão: @code{5000})"

msgid "{Data Type} patchwork-configuration"
msgstr "{Tipo de dados} patchwork-configuration"

msgid "domain"
msgstr "domain"

msgid "{Data Type} patchwork-settings-module"
msgstr "{Tipo de dados} patchwork-settings-module"

msgid "{Data Type} patchwork-database-configuration"
msgstr "{Tipo de dados} patchwork-database-configuration"

msgid "@code{port} (default: @code{\"\"})"
msgstr "@code{port} (padrão: @code{\"\"})"

msgid "{Data Type} mumi-configuration"
msgstr "{Tipo de dados} mumi-configuration"

msgid "{Data Type} fcgiwrap-configuration"
msgstr "{Tipo de dados} fcgiwrap-configuration"

msgid "...@: and much more."
msgstr "...@: e muito mais."

msgid "{Data Type} php-fpm-configuration"
msgstr "{Tipo de dados} php-fpm-configuration"

msgid "@code{file} (default @code{#f})"
msgstr "@code{file} (padrão @code{#f})"

msgid "{Data type} php-fpm-dynamic-process-manager-configuration"
msgstr "{Tipo de dados} php-fpm-dynamic-process-manager-configuration"

msgid "{Data type} php-fpm-static-process-manager-configuration"
msgstr "{Tipo de dados} php-fpm-static-process-manager-configuration"

msgid "{Data type} php-fpm-on-demand-process-manager-configuration"
msgstr "{Tipo de dados} php-fpm-on-demand-process-manager-configuration"

msgid "{Data Type} hpcguix-web-configuration"
msgstr "{Tipo de dados} hpcguix-web-configuration"

msgid "{Data Type} gmnisrv-configuration"
msgstr "{Tipo de dados} gmnisrv-configuration"

msgid "{Data Type} agate-configuration"
msgstr "{Tipo de dados} agate-configuration"

msgid "{Data Type} certbot-configuration"
msgstr "{Tipo de dados} certbot-configuration"

msgid "{Data Type} certificate-configuration"
msgstr "{Tipo de dados} certificate-configuration"

msgid "@code{challenge} (default: @code{#f})"
msgstr "@code{challenge} (padrão: @code{#f})"

msgid "@code{authentication-hook} (default: @code{#f})"
msgstr "@code{authentication-hook} (padrão: @code{#f})"

msgid "@code{cleanup-hook} (default: @code{#f})"
msgstr "@code{cleanup-hook} (padrão: @code{#f})"

msgid "{Data Type} knot-key-configuration"
msgstr "{Tipo de dados} knot-key-configuration"

msgid "@code{algorithm} (default: @code{#f})"
msgstr "@code{algorithm} (padrão: @code{#f})"

msgid "{Data Type} knot-acl-configuration"
msgstr "{Tipo de dados} knot-acl-configuration"

msgid "@code{deny?} (default: @code{#f})"
msgstr "@code{deny?} (padrão: @code{#f})"

msgid "{Data Type} zone-entry"
msgstr "{Tipo de dados} zone-entry"

msgid "{Data Type} zone-file"
msgstr "{Tipo de dados} zone-file"

msgid "{Data Type} knot-remote-configuration"
msgstr "{Tipo de dados} knot-remote-configuration"

msgid "@code{key} (default: @code{#f})"
msgstr "@code{key} (padrão: @code{#f})"

msgid "{Data Type} knot-keystore-configuration"
msgstr "{Tipo de dados} knot-keystore-configuration"

msgid "{Data Type} knot-policy-configuration"
msgstr "{Tipo de dados} knot-policy-configuration"

msgid "@code{manual?} (default: @code{#f})"
msgstr "@code{manual?} (padrão: @code{#f})"

msgid "@code{nsec3?} (default: @code{#f})"
msgstr "@code{nsec3?} (padrão: @code{#f})"

msgid "{Data Type} knot-zone-configuration"
msgstr "{Tipo de dados} knot-zone-configuration"

msgid "@code{zonefile-load} (default: @code{#f})"
msgstr "@code{zonefile-load} (padrão: @code{#f})"

msgid "@code{max-journal-usage} (default: @code{#f})"
msgstr "@code{max-journal-usage} (padrão: @code{#f})"

msgid "@code{max-journal-depth} (default: @code{#f})"
msgstr "@code{max-journal-depth} (padrão: @code{#f})"

msgid "@code{max-zone-size} (default: @code{#f})"
msgstr "@code{max-zone-size} (padrão: @code{#f})"

msgid "@code{dnssec-policy} (default: @code{#f})"
msgstr "@code{dnssec-policy} (padrão: @code{#f})"

msgid "{Data Type} knot-configuration"
msgstr "{Tipo de dados} knot-configuration"

msgid "{Data Type} knot-resolver-configuration"
msgstr "{Tipo de dados} knot-resolver-configuration"

msgid "{Data Type} dnsmasq-configuration"
msgstr "{Tipo de dados} dnsmasq-configuration"

msgid "@code{no-hosts?} (default: @code{#f})"
msgstr "@code{no-hosts?} (padrão: @code{#f})"

msgid "@code{port} (default: @code{53})"
msgstr "@code{port} (padrão: @code{53})"

msgid "@code{local-service?} (default: @code{#t})"
msgstr "@code{local-service?} (padrão: @code{#t})"

msgid "@code{no-resolv?} (default: @code{#f})"
msgstr "@code{no-resolv?} (padrão: @code{#f})"

msgid "@code{cache-size} (default: @code{150})"
msgstr "@code{cache-size} (padrão: @code{150})"

msgid "@code{negative-cache?} (default: @code{#t})"
msgstr "@code{negative-cache?} (padrão: @code{#t})"

msgid "{Data Type} xvnc-configuration"
msgstr "{Tipo de dados} xvnc-configuration"

msgid "{Data Type} openvpn-client-configuration"
msgstr "{Tipo de dados} openvpn-client-configuration"

msgid "{Data Type} openvpn-remote-configuration"
msgstr "{Tipo de dados} openvpn-remote-configuration"

msgid "Server name."
msgstr "Nome do servidor."

msgid "{Data Type} openvpn-server-configuration"
msgstr "{Tipo de dados} openvpn-server-configuration"

msgid "{Data Type} strongswan-configuration"
msgstr "{Tipo de dados} strongswan-configuration"

msgid "{Data Type} wireguard-configuration"
msgstr "{Tipo de dados} wireguard-configuration"

msgid "@code{port} (default: @code{51820})"
msgstr "@code{port} (padrão: @code{51820})"

msgid "{Data Type} wireguard-peer"
msgstr "{Tipo de dados} wireguard-peer"

msgid "public-key"
msgstr "public-key"

msgid "@code{port} (default: @code{8080})"
msgstr "@code{port} (padrão: @code{8080})"

msgid "NFS"
msgstr "NFS"

msgid "{Data Type} nfs-configuration"
msgstr "{Tipo de dados} nfs-configuration"

msgid "{Data Type} rpcbind-configuration"
msgstr "{Tipo de dados} rpcbind-configuration"

msgid "{Data Type} pipefs-configuration"
msgstr "{Tipo de dados} pipefs-configuration"

msgid "{Data Type} gss-configuration"
msgstr "{Tipo de dados} gss-configuration"

msgid "{Data Type} idmap-configuration"
msgstr "{Tipo de dados} idmap-configuration"

msgid "@code{domain} (default: @code{#f})"
msgstr "@code{domain} (padrão: @code{#f})"

msgid "Samba"
msgstr "Samba"

msgid "SMB"
msgstr "SMB"

msgid "{Data Type} samba-service-configuration"
msgstr "{Tipo de dados} samba-service-configuration"

msgid "Web Service Discovery Daemon"
msgstr "Daemon de Descoberta de Serviço da Web"

msgid "{Data Type} wsdd-configuration"
msgstr "{Tipo de dados} wsdd-configuration"

msgid "{Data Type} cuirass-configuration"
msgstr "{Tipo de dados} cuirass-configuration"

msgid "@code{port} (default: @code{8081})"
msgstr "@code{port} (padrão: @code{8081})"

msgid "@code{fallback?} (default: @code{#f})"
msgstr "@code{fallback?} (padrão: @code{#f})"

msgid "{Data Type} cuirass-remote-server-configuration"
msgstr "{Tipo de dados} cuirass-remote-server-configuration"

msgid "{Data Type} cuirass-remote-worker-configuration"
msgstr "{Tipo de dados} cuirass-remote-worker-configuration"

msgid "{Data Type} laminar-configuration"
msgstr "{Tipo de dados} laminar-configuration"

msgid "token"
msgstr "token"

msgid "{Data Type} power-profiles-daemon-configuration"
msgstr "{Tipo de dados} power-profiles-daemon-configuration"

msgid "{Data Type} thermald-configuration"
msgstr "{Tipo de dados} thermald-configuration"

msgid "mpd"
msgstr "mpd"

msgid "Music Player Daemon"
msgstr "Daemon do reprodutor de música"

msgid "{Data Type} mpd-configuration"
msgstr "{Tipo de dados} mpd-configuration"

msgid "{Data Type} mpd-plugin"
msgstr "{Tipo de dados} mpd-plugin"

msgid "Name."
msgstr "Nome."

msgid "{Data Type} mpd-partition"
msgstr "{Tipo de dados} mpd-partition"

msgid "{Data Type} mpd-output"
msgstr "{Tipo de dados} mpd-output"

msgid "{Data Type} mympd-configuration"
msgstr "{Tipo de dados} mympd-configuration"

msgid "{Data Type} mympd-ip-acl"
msgstr "{Tipo de dados} mympd-ip-acl"

msgid "output to a file, with the given filepath"
msgstr "saída para um arquivo, com o caminho de arquivo dado"

msgid "{Data Type} qemu-binfmt-configuration"
msgstr "{Tipo de dados} qemu-binfmt-configuration"

msgid "Service type for the QEMU guest agent service."
msgstr "Tipo de serviço para o serviço de agente convidado QEMU."

msgid "{Data Type} qemu-guest-agent-configuration"
msgstr "{Tipo de dados} qemu-guest-agent-configuration"

msgid "{Data Type} virtual-build-machine"
msgstr "{Tipo de dados} virtual-build-machine"

msgid "image"
msgstr "image"

msgid "{Data Type} hurd-vm-configuration"
msgstr "{Tipo de dados} hurd-vm-configuration"

msgid "{Data Type} ganeti-configuration"
msgstr "{Tipo de dados} ganeti-configuration"

msgid "{Data Type} ganeti-os"
msgstr "{Tipo de dados} ganeti-os"

msgid "{Data Type} ganeti-os-variant"
msgstr "{Tipo de dados} ganeti-os-variant"

msgid "configuration"
msgstr "configuration"

msgid "{Data Type} debootstrap-configuration"
msgstr "{Tipo de dados} debootstrap-configuration"

msgid "{Data Type} ganeti-noded-configuration"
msgstr "{Tipo de dados} ganeti-noded-configuration"

msgid "@code{port} (default: @code{1811})"
msgstr "@code{port} (padrão: @code{1811})"

msgid "{Data Type} ganeti-confd-configuration"
msgstr "{Tipo de dados} ganeti-confd-configuration"

msgid "@code{port} (default: @code{1814})"
msgstr "@code{port} (padrão: @code{1814})"

msgid "{Data Type} ganeti-wconfd-configuration"
msgstr "{Tipo de dados} ganeti-wconfd-configuration"

msgid "{Data Type} ganeti-luxid-configuration"
msgstr "{Tipo de dados} ganeti-luxid-configuration"

msgid "{Data Type} ganeti-rapi-configuration"
msgstr "{Tipo de dados} ganeti-rapi-configuration"

msgid "@code{port} (default: @code{5080})"
msgstr "@code{port} (padrão: @code{5080})"

msgid "{Data Type} ganeti-kvmd-configuration"
msgstr "{Tipo de dados} ganeti-kvmd-configuration"

msgid "{Data Type} ganeti-mond-configuration"
msgstr "{Tipo de dados} ganeti-mond-configuration"

msgid "@code{port} (default: @code{1815})"
msgstr "@code{port} (padrão: @code{1815})"

msgid "{Data Type} ganeti-metad-configuration"
msgstr "{Tipo de dados} ganeti-metad-configuration"

msgid "{Data Type} ganeti-watcher-configuration"
msgstr "{Tipo de dados} ganeti-watcher-configuration"

msgid "{Data Type} ganeti-cleaner-configuration"
msgstr "{Tipo de dados} ganeti-cleaner-configuration"

msgid "{Data Type} git-daemon-configuration"
msgstr "{Tipo de dados} git-daemon-configuration"

msgid "@code{port} (default: @code{#f})"
msgstr "@code{port} (padrão: @code{#f})"

msgid "{Data Type} git-http-configuration"
msgstr "{Tipo de dados} git-http-configuration"

msgid "{Data Type} gitolite-configuration"
msgstr "{Tipo de dados} gitolite-configuration"

msgid "{Data Type} gitolite-rc-file"
msgstr "{Tipo de dados} gitolite-rc-file"

msgid "@code{umask} (default: @code{#o0077})"
msgstr "@code{umask} (padrão: @code{#o0077})"

msgid "Gitile service"
msgstr "Serviço Gitile"

msgid "{Data Type} gitile-configuration"
msgstr "{Tipo de dados} gitile-configuration"

msgid "{Data Type} joycond-configuration"
msgstr "{Tipo de dados} joycond-configuration"

msgid "{Data Type} wesnothd-configuration"
msgstr "{Tipo de dados} wesnothd-configuration"

msgid "@code{port} (default: @code{15000})"
msgstr "@code{port} (padrão: @code{15000})"

msgid "{Data Type} pam-mount-configuration"
msgstr "{Tipo de dados} pam-mount-configuration"

msgid "rules"
msgstr "rules"

msgid "{Data Type} pam-mount-volume-service-type"
msgstr "{Tipo de dados} pam-mount-volume-service-type"

msgid "{Data Type} bffe-configuration"
msgstr "{Tipo de dados} bffe-configuration"

msgid "{Data Type} guix-build-coordinator-configuration"
msgstr "{Tipo de dados} guix-build-coordinator-configuration"

msgid "{Data Type} guix-build-coordinator-agent-configuration"
msgstr "{Tipo de dados} guix-build-coordinator-agent-configuration"

msgid "authentication"
msgstr "authentication"

msgid "{Data Type} guix-build-coordinator-agent-password-auth"
msgstr "{Tipo de dados} guix-build-coordinator-agent-password-auth"

msgid "{Data Type} guix-build-coordinator-agent-password-file-auth"
msgstr "{Tipo de dados} guix-build-coordinator-agent-password-file-auth"

msgid "{Data Type} guix-build-coordinator-agent-dynamic-auth"
msgstr "{Tipo de dados} guix-build-coordinator-agent-dynamic-auth"

msgid "{Data Type} guix-build-coordinator-agent-dynamic-auth-with-file"
msgstr "{Tipo de dados} guix-build-coordinator-agent-dynamic-auth-with-file"

msgid "{Data Type} guix-data-service-configuration"
msgstr "{Tipo de dados} guix-data-service-configuration"

msgid "@code{port} (default: @code{8765})"
msgstr "@code{port} (padrão: @code{8765})"

msgid "{Data Type} nar-herder-configuration"
msgstr "{Tipo de dados} nar-herder-configuration"

msgid "@code{port} (default: @code{8734})"
msgstr "@code{port} (padrão: @code{8734})"

msgid "{Data Type} nar-herder-cached-compression-configuration"
msgstr "{Tipo de dados} nar-herder-cached-compression-configuration"

msgid "{Data Type} earlyoom-configuration"
msgstr "{Tipo de dados} earlyoom-configuration"

msgid "{Data Type} fstrim-configuration"
msgstr "{Tipo de dados} fstrim-configuration"

msgid "{Data Type} cachefilesd-configuration"
msgstr "{Tipo de dados} cachefilesd-configuration"

msgid "{Data Type} rasdaemon-configuration"
msgstr "{Tipo de dados} rasdaemon-configuration"

msgid "{Data Type} zram-device-configuration"
msgstr "{Tipo de dados} zram-device-configuration"

msgid "{Data Type} hurd-console-configuration"
msgstr "{Tipo de dados} hurd-console-configuration"

msgid "{Data Type} hurd-getty-configuration"
msgstr "{Tipo de dados} hurd-getty-configuration"

msgid "{Data Type} sysctl-configuration"
msgstr "{Tipo de dados} sysctl-configuration"

msgid "{Data Type} pcscd-configuration"
msgstr "{Tipo de dados} pcscd-configuration"

msgid "{Data Type} lirc-configuration"
msgstr "{Tipo de dados} lirc-configuration"

msgid "SPICE"
msgstr "SPICE"

msgid "{Data Type} spice-vdagent-configuration"
msgstr "{Tipo de dados} spice-vdagent-configuration"

msgid "{Data Type} inputattach-configuration"
msgstr "{Tipo de dados} inputattach-configuration"

msgid "@code{device} (default: @code{\"/dev/ttyS0\"})"
msgstr "@code{device} (padrão: @code{\"/dev/ttyS0\"})"

msgid "dictionary"
msgstr "dicionário"

msgid "{Data Type} dicod-configuration"
msgstr "{Tipo de dados} dicod-configuration"

msgid "{Data Type} dicod-handler"
msgstr "{Tipo de dados} dicod-handler"

msgid "{Data Type} dicod-database"
msgstr "{Tipo de dados} dicod-database"

msgid "Docker"
msgstr "Docker"

msgid "{Data Type} containerd-configuration"
msgstr "{Tipo de dados} containerd-configuration"

msgid "{Data Type} docker-configuration"
msgstr "{Tipo de dados} docker-configuration"

msgid "{Data Type} oci-container-configuration"
msgstr "{Tipo de dados} oci-container-configuration"

msgid "{Data Type} oci-image"
msgstr "{Tipo de dados} oci-image"

msgid "@command{auditctl} from the @code{audit} package can be used in order to add or remove events to be tracked (until the next reboot).  In order to permanently track events, put the command line arguments of auditctl into a file called @code{audit.rules} in the configuration directory (see below).  @command{aureport} from the @code{audit} package can be used in order to view a report of all recorded events.  The audit daemon by default logs into the file @file{/var/log/audit.log}."
msgstr "@command{auditctl} do pacote @code{audit} pode ser usado para adicionar ou remover eventos a serem rastreaddos (até o próximo reinício). A fim de rastrear permanentemente eventos, ponha os argumentos de linha de comando do auditctl num arquivo chamado @code{audit.rules} no diretório de configurações (veja abaixo). @command{aureport} do pacote @code{audit} pode ser usado para visualizar um relatório de todos os eventos gravados. O daemon audit por padrão, produz logs no arquivo @file{/var/log/audit.log}."

msgid "{Data Type} auditd-configuration"
msgstr "{Tipo de dados} auditd-configuration"

msgid "{Data Type} rshiny-configuration"
msgstr "{Tipo de dados} rshiny-configuration"

msgid "{Data Type} nix-configuration"
msgstr "{Tipo de dados} nix-configuration"

msgid "{Data Type} fail2ban-configuration"
msgstr "{Tipo de dados} fail2ban-configuration"

msgid "{Data Type} fail2ban-ignore-cache-configuration"
msgstr "{Tipo de dados} fail2ban-ignore-cache-configuration"

msgid "{Data Type} fail2ban-jail-action-configuration"
msgstr "{Tipo de dados} fail2ban-jail-action-configuration"

msgid "{Data Type} fail2ban-jail-configuration"
msgstr "{Tipo de dados} fail2ban-jail-configuration"

msgid "{Data Type} fail2ban-jail-filter-configuration"
msgstr "{Tipo de dados} fail2ban-jail-filter-configuration"

msgid "{Data Type} restic-backup-configuration"
msgstr "{Tipo de dados} restic-backup-configuration"

msgid "{Data Type} restic-backup-job"
msgstr "{Tipo de dados} restic-backup-job"

msgid "{Data Type} readymedia-configuration"
msgstr "{Tipo de dados} readymedia-configuration"

msgid "{Data Type} readymedia-media-directory"
msgstr "{Tipo de dados} readymedia-media-directory"

msgid "{Data Type} privileged-program"
msgstr "{Tipo de dados} privileged-program"

msgid "X.509 certificates"
msgstr "Certificados X.509"

msgid "{Data Type} name-service-switch"
msgstr "{Tipo de dados} name-service-switch"

msgid "hosts"
msgstr "hosts"

msgid "networks"
msgstr "networks"

msgid "{Data Type} name-service"
msgstr "{Tipo de dados} name-service"

msgid "{Data Type} bootloader-configuration"
msgstr "{Tipo de dados} bootloader-configuration"

msgid "keyboard layout, for the bootloader"
msgstr "disposição do teclado, para o carregador de inicialização"

msgid "{Data Type} menu-entry"
msgstr "{Tipo de dados} menu-entry"

msgid "{Data Type} grub-theme"
msgstr "{Tipo de dados} grub-theme"

msgid "search"
msgstr "search"

msgid "@dots{}\n"
msgstr "@dots{}\n"

msgid "edit"
msgstr "edit"

msgid "guix system vm"
msgstr "guix system vm"

msgid "debug"
msgstr "debug"

msgid "$ guix system list-generations 10d\n"
msgstr "$ guix system list-generations 10d\n"

msgid "system-extension-graph"
msgstr "system-extension-graph"

msgid "extension-graph"
msgstr "extension-graph"

msgid "The command:"
msgstr "O comando:"

msgid "system-shepherd-graph"
msgstr "system-shepherd-graph"

msgid "shepherd-graph"
msgstr "shepherd-graph"

msgid "{Data Type} machine"
msgstr "{Tipo de dados} machine"

msgid "environment"
msgstr "environment"

msgid "{Data Type} machine-ssh-configuration"
msgstr "{Tipo de dados} machine-ssh-configuration"

msgid "system"
msgstr "system"

msgid "{Data Type} digital-ocean-configuration"
msgstr "{Tipo de dados} digital-ocean-configuration"

msgid "ssh-key"
msgstr "ssh-key"

msgid "region"
msgstr "region"

msgid "Running Guix in a Virtual Machine"
msgstr "Usando o Guix em uma Máquina Virtual"

msgid "QEMU"
msgstr "QEMU"

msgid "{Data Type} service-type"
msgstr "{Tipo de dados} service-type"

msgid "service type"
msgstr "tipo de serviço"

msgid "extensions"
msgstr "extensions"

msgid "@code{compose} (default: @code{#f})"
msgstr "@code{compose} (padrão: @code{#f})"

msgid "@code{extend} (default: @code{#f})"
msgstr "@code{extend} (padrão: @code{#f})"

msgid "{Data Type} shepherd-service"
msgstr "{Tipo de dados} shepherd-service"

msgid "@code{respawn?} (default: @code{#t})"
msgstr "@code{respawn?} (padrão: @code{#t})"

msgid "{Data Type} shepherd-action"
msgstr "{Tipo de dados} shepherd-action"

msgid "procedure"
msgstr "procedure"

msgid "{Data Type} shepherd-configuration"
msgstr "{Tipo de dados} shepherd-configuration"

msgid "home configuration"
msgstr "Configuração pessoal"

msgid "Using Guix for managing home environments provides a number of advantages:"
msgstr "Usar o Guix para gerenciar seu ambiente pessoal traz várias vantagens."

msgid "home services"
msgstr "serviços pessoais"

msgid "{Data Type} home-dotfiles-configuration"
msgstr "{Tipo de dados} home-dotfiles-configuration"

msgid "{Data Type} home-shell-profile-configuration"
msgstr "{Tipo de dados} home-shell-profile-configuration"

msgid "{Data Type} home-bash-configuration"
msgstr "{Tipo de dados} home-bash-configuration"

msgid "{Data Type} home-bash-extension"
msgstr "{Tipo de dados} home-bash-extension"

msgid "{Data Type} home-zsh-configuration"
msgstr "{Tipo de dados} home-zsh-configuration"

msgid "{Data Type} home-inputrc-configuration"
msgstr "{Tipo de dados} home-inputrc-configuration"

msgid "Scheduled User's Job Execution"
msgstr "Execução de trabalho agendado pessoal"

msgid "{Data Type} home-mcron-configuration"
msgstr "{Tipo de dados} home-mcron-configuration"

msgid "{Data Type} home-batsignal-configuration"
msgstr "{Tipo de dados} home-batsignal-configuration"

msgid "{Data Type} home-shepherd-configuration"
msgstr "{Tipo de dados} home-shepherd-configuration"

msgid "Secure Shell"
msgstr "Secure Shell"

msgid "{Data Type} home-openssh-configuration"
msgstr "{Tipo de dados} home-openssh-configuration"

msgid "{Data Type} openssh-host"
msgstr "{Tipo de dados} openssh-host"

msgid "{Data Type} proxy-jump"
msgstr "{Tipo de dados} proxy-jump"

msgid "{Data Table} home-parcimonie-configuration"
msgstr "{Tipo de dados} home-parcimonie-configuration"

msgid "{Data Type} home-ssh-agent-configuration"
msgstr "{Tipo de dados} home-ssh-agent-configuration"

msgid "{Data Type} home-gpg-agent-configuration"
msgstr "{Tipo de dados} home-gpg-agent-configuration"

msgid "{Data Type} home-redshift-configuration"
msgstr "{Tipo de dados} home-redshift-configuration"

msgid "{Data Type} home-dbus-configuration"
msgstr "{Tipo de dados} home-dbus-configuration"

msgid "{Data Type} home-unclutter-configuration"
msgstr "{Tipo de dados} home-unclutter-configuration"

msgid "{Data Type} home-xmodmap-configuration"
msgstr "{Tipo de dados} home-xmodmap-configuration"

msgid "PulseAudio, home service"
msgstr "PulseAudio, serviço pessoal"

msgid "PipeWire, home service"
msgstr "PipeWire, serviço pessoal"

msgid "{Data Type} home-pipewire-configuration"
msgstr "{Tipo de dados} home-pipewire-configuration"

msgid "{Data Type} home-msmtp-configuration"
msgstr "{Tipo de dados} home-msmtp-configuration"

msgid "{Data Type} msmtp-account"
msgstr "{Tipo de dados} msmtp-account"

msgid "{Data Type} msmtp-configuration"
msgstr "{Tipo de dados} msmtp-configuration"

msgid "{Data Type} home-znc-configuration"
msgstr "{Tipo de dados} home-znc-configuration"

msgid "{Data Type} home-kodi-configuration"
msgstr "{Tipo de dados} home-kodi-configuration"

msgid "Sway window manager"
msgstr "Gerenciador de janelas Sway"

msgid "{Data Type} sway-configuration"
msgstr "{Tipo de dados} sway-configuration"

msgid "Example:"
msgstr "Exemplo:"

msgid "{Data Type} sway-input"
msgstr "{Tipo de dados} sway-input"

msgid "{Data Type} sway-output"
msgstr "{Tipo de dados} sway-output"

msgid "{Data Type} sway-border-color"
msgstr "{Tipo de dados} sway-border-color"

msgid "{Data Type} sway-color"
msgstr "{Tipo de dados} sway-color"

msgid "{Data Type} sway-bar"
msgstr "{Tipo de dados} sway-bar"

msgid "{Data Type} sway-mode"
msgstr "{Tipo de dados} sway-mode"

msgid "provenance tracking, of the home environment"
msgstr "rastreamento de proveniência, do ambiente pessoal"

msgid "import"
msgstr "import"

msgid ""
"$ man -k TLS\n"
"SSL (7)              - OpenSSL SSL/TLS library\n"
"certtool (1)         - GnuTLS certificate tool\n"
"@dots {}\n"
msgstr ""
"$ man -k TLS\n"
"SSL (7)              - OpenSSL SSL/TLS library\n"
"certtool (1)         - GnuTLS certificate tool\n"
"@dots {}\n"

msgid "{Data Type} platform"
msgstr "{Tipo de dados} platform"

msgid "system images"
msgstr "imagens de sistema"

msgid "{Data Type} image"
msgstr "{Tipo de dados} image"

msgid "Whether to use the host network interfaces within the image, as a boolean.  This is only used for the @code{'docker} image format.  It defaults to @code{#false}."
msgstr "Se deve usar as interfaces de rede do host dentro da imagem, como um booleano. Isso é usado apenas para o formato de imagem @code{'docker}. O padrão é @code{#false}."

msgid "@code{partition} Reference"
msgstr "Referência do @code{partition}"

msgid "{Data Type} partition"
msgstr "{Tipo de dados} partition"

msgid "The partition file system creation options that should be passed to the partition creation tool, as a list of strings.  This is only supported when creating @code{\"vfat\"}, @code{\"fat16\"}, @code{\"fat32\"} or @code{\"ext4\"} partitions."
msgstr "As opções de criação do sistema de arquivos de partição que devem ser passadas para a ferramenta de criação de partição, como uma lista de strings. Isso só é suportado ao criar partições @code{\"vfat\"}, @code{\"fat16\"}, @code{\"fat32\"} ou @code{\"ext4\"}."

msgid "Note that the first and third partitions use generic initializers procedures, initialize-efi-partition and initialize-root-partition respectively.  The initialize-efi-partition installs a GRUB EFI loader that is loading the GRUB bootloader located in the root partition.  The initialize-root-partition instantiates a complete system as defined by the @code{%simple-os} operating-system."
msgstr "Note que a primeira e a terceira partições usam procedimentos de inicializadores genéricos, initialize-efi-partition e initialize-root-partition, respectivamente. O initialize-efi-partition instala um carregador EFI GRUB que está carregando o carregador de inicialização GRUB localizado na partição raiz. O initialize-root-partition instancia um sistema completo conforme definido pelo sistema operacional @code{%simple-os}."

msgid "You can now run:"
msgstr "Agora você pode executar:"

msgid "guix system image my-image.scm\n"
msgstr "guix system image my-image.scm\n"

msgid "to instantiate the @code{image} definition.  That produces a disk image which has the expected structure:"
msgstr "para instanciar a definição @code{image}. Isso produz uma imagem de disco que tem a estrutura esperada:"

msgid "A Docker image that can be used to spawn a Docker container."
msgstr "Uma imagem do Docker que pode ser usada para gerar um contêiner do Docker."

msgid "{Data Type} image-type"
msgstr "{Tipo de dados} image-type"

msgid "Build an image based on the @code{mbr-disk-image} image."
msgstr "Crie uma imagem baseada na imagem @code{mbr-disk-image}."

msgid "Build an MBR image with a single partition starting at a @code{1024KiB} offset.  This is useful to leave some room to install a bootloader in the post-MBR gap."
msgstr "Crie uma imagem MBR com uma única partição começando em um deslocamento @code{1024KiB}. Isso é útil para deixar algum espaço para instalar um bootloader na lacuna pós-MBR."

msgid "So, if we get back to the @code{guix system image} command taking an @code{operating-system} declaration as argument.  By default, the @code{mbr-raw-image-type} is used to turn the provided @code{operating-system} into an actual bootable image."
msgstr "Então, se voltarmos ao comando @code{guix system image} tomando uma declaração @code{operating-system} como argumento. Por padrão, o @code{mbr-raw-image-type} é usado para transformar o @code{operating-system} fornecido em uma imagem inicializável real."

msgid "To use a different @code{image-type}, the @code{--image-type} option can be used.  The @code{--list-image-types} option will list all the supported image types.  It turns out to be a textual listing of all the @code{image-types} variables described just above (@pxref{Invoking guix system})."
msgstr "Para usar um @code{image-type} diferente, a opção @code{--image-type} pode ser usada. A opção @code{--list-image-types} listará todos os tipos de imagem suportados. Acontece que é uma listagem textual de todas as variáveis @code{image-types} descritas logo acima (@pxref{Invoking guix system})."

msgid "Let's take the example of the Pine64, an ARM based machine.  To be able to produce an image targeting this board, we need the following elements:"
msgstr "Vamos pegar o exemplo do Pine64, uma máquina baseada em ARM. Para poder produzir uma imagem direcionada a essa placa, precisamos dos seguintes elementos:"

msgid "An @code{operating-system} record containing at least"
msgstr "Um registro @code{operating-system} contendo pelo menos"

msgid "an appropriate kernel (@code{linux-libre-arm64-generic}) and bootloader @code{u-boot-pine64-lts-bootloader}) for the Pine64."
msgstr "um kernel apropriado (@code{linux-libre-arm64-generic}) e bootloader @code{u-boot-pine64-lts-bootloader}) para o Pine64."

msgid "The problem with debugging information is that it takes up a fair amount of disk space.  For example, debugging information for the GNU C Library weighs in at more than 60 MiB@.  Thus, as a user, keeping all the debugging info of all the installed programs is usually not an option.  Yet, space savings should not come at the cost of an impediment to debugging---especially in the GNU system, which should make it easier for users to exert their computing freedom (@pxref{GNU Distribution})."
msgstr "O problema com informações de depuração é que elas ocupam uma quantidade considerável de espaço em disco. Por exemplo, informações de depuração para a GNU C Library pesam mais de 60 MiB@. Assim, como usuário, manter todas as informações de depuração de todos os programas instalados geralmente não é uma opção. No entanto, a economia de espaço não deve vir ao custo de um impedimento à depuração --- especialmente no sistema GNU, o que deve tornar mais fácil para os usuários exercerem sua liberdade de computação (@pxref{GNU Distribution})."

msgid "As we saw above, some packages, but not all, provide debugging info in a @code{debug} output.  What can you do when debugging info is missing? The @option{--with-debug-info} option provides a solution to that: it allows you to rebuild the package(s) for which debugging info is missing---and only those---and to graft those onto the application you're debugging.  Thus, while it's not as fast as installing a @code{debug} output, it is relatively inexpensive."
msgstr "Como vimos acima, alguns pacotres, mas não todos, provêem informação de depuração numa saída @code{debug}.  O que podemos fazer quando informação de depuração está faltando? A opção @option{--with-debug-info} provê uma solução para isso: ela te permite reconstruir os pacotes para os quais a informação está faltando --- e nomente estes --- e exertá-los no aplicativo que você está deupurando.  Portanto, enquanto isso não é tão rápido quanto a instalação de uma saída do @code{debug}, isso é relativamente menos custoso."

msgid "Using @TeX{} and @LaTeX{}"
msgstr "Usando @TeX{} e @LaTeX{}"

msgid "@TeX{} packages"
msgstr "pacotes @TeX{}"

msgid "@LaTeX{} packages"
msgstr "pacotes @LaTeX{}"

msgid "If needed, you may then complete your system with individual packages, particularly when they belong to a large collection you're not otherwise interested in."
msgstr "Se necessário, você pode completar seu sistema com pacotes individuais, principalmente quando eles pertencem a uma coleção grande na qual você não tem interesse."

msgid "For instance, the following manifest is a reasonable, yet frugal starting point for a French @LaTeX{} user:"
msgstr "Por exemplo. o seguinte manifesto e algo razoável, e ainda um ponto de partidal frugal para um usuário francês de @LaTeX{}:"

msgid "How do you determine what the missing package is? In the first case, you will find the answer by running:"
msgstr "Como determinar qual é o pacote que falta? No primeiro caso, encontrará a resposta executando:"

msgid "In the second case, @command{guix search} turns up nothing.  Instead, you can search the @TeX{} Live package database using the @command{tlmgr} command:"
msgstr "No segundo caso, @command{guix search} não fornece nada.  Ao invés disso, você pode buscar na base de dados de pacotes do @TeX{} Live usando o comando @command{tlmgr}:"

msgid "The file is available in the @TeX{} Live @code{helvetic} package, which is known in Guix as @code{texlive-helvetic}.  Quite a ride, but you found it!"
msgstr "O arquivo está disponível no pacote @TeX{} Live @code{helvetic}, que é conhecido no Guix como @code{texlive-helvetic}. Uma viagem e tanto, mas você encontrou!"

msgid "security updates"
msgstr "atualizações de segurança"

msgid "Occasionally, important security vulnerabilities are discovered in software packages and must be patched.  Guix developers try hard to keep track of known vulnerabilities and to apply fixes as soon as possible in the @code{master} branch of Guix (we do not yet provide a ``stable'' branch containing only security updates).  The @command{guix lint} tool helps developers find out about vulnerable versions of software packages in the distribution:"
msgstr "Ocasionalmente, vulnerabilidades de segurança importantes são descobertas em pacotes de software e devem ser corrigidas. Os desenvolvedores do Guix se esforçam para manter o controle das vulnerabilidades conhecidas e aplicar correções o mais rápido possível no branch @code{master} do Guix (ainda não fornecemos um branch ``stable'' contendo apenas atualizações de segurança). A ferramenta @command{guix lint} ajuda os desenvolvedores a descobrirem sobre versões vulneráveis de pacotes de software na distribuição:"

msgid "@xref{Invoking guix lint}, for more information."
msgstr "@xref{Invoking guix lint}, para mais informações."

msgid "Guix follows a functional package management discipline (@pxref{Introduction}), which implies that, when a package is changed, @emph{every package that depends on it} must be rebuilt.  This can significantly slow down the deployment of fixes in core packages such as libc or Bash, since basically the whole distribution would need to be rebuilt.  Using pre-built binaries helps (@pxref{Substitutes}), but deployment may still take more time than desired."
msgstr "Guix segue uma disciplina de gerenciamento de pacotes funcional (@pxref{Introdução}), o que implica que, quando um pacote é alterado, @emph{todo pacote que depende dele} deve ser reconstruído. Isso pode desacelerar significativamente a implantação de correções em pacotes principais, como libc ou Bash, já que basicamente toda a distribuição precisaria ser reconstruída. Usar binários pré-construídos ajuda (@pxref{Substitutos}), mas a implantação ainda pode levar mais tempo do que o desejado."

msgid "@dots{} and compare the store file names that you get with those above.  Likewise for a complete Guix system generation:"
msgstr "@dots{} e compare os nomes dos arquivos de armazém que você obtém com os acima. Da mesma forma para uma geração completa do sistema Guix:"

msgid "Lastly, to check which Bash running processes are using, you can use the @command{lsof} command:"
msgstr "Por fim, para verificar quais processos Bash estão em execução, você pode usar o comando @command{lsof}:"

msgid "bootstrapping"
msgstr "inicialização"

msgid "Bootstrapping in our context refers to how the distribution gets built ``from nothing''.  Remember that the build environment of a derivation contains nothing but its declared inputs (@pxref{Introduction}).  So there's an obvious chicken-and-egg problem: how does the first package get built? How does the first compiler get compiled?"
msgstr "Bootstrapping em nosso contexto se refere a como a distribuição é construída ``do nada''. Lembre-se de que o ambiente de construção de uma derivação não contém nada além de suas entradas declaradas (@pxref{Introdução}). Então há um problema óbvio de galinha e ovo: como o primeiro pacote é construído? Como o primeiro compilador é compilado?"

msgid "It is tempting to think of this question as one that only die-hard hackers may care about.  However, while the answer to that question is technical in nature, its implications are wide-ranging.  How the distribution is bootstrapped defines the extent to which we, as individuals and as a collective of users and hackers, can trust the software we run.  It is a central concern from the standpoint of @emph{security} and from a @emph{user freedom} viewpoint."
msgstr "É tentador pensar nessa questão como algo com que apenas hackers obstinados podem se importar. No entanto, embora a resposta a essa questão seja de natureza técnica, suas implicações são abrangentes. Como a distribuição é bootstrapped define até que ponto nós, como indivíduos e como um coletivo de usuários e hackers, podemos confiar no software que executamos. É uma preocupação central do ponto de vista da @emph{segurança} e do ponto de vista da @emph{liberdade do usuário}."

msgid "bootstrap binaries"
msgstr "binários bootstrap"

msgid "The GNU system is primarily made of C code, with libc at its core.  The GNU build system itself assumes the availability of a Bourne shell and command-line tools provided by GNU Coreutils, Awk, Findutils, `sed', and `grep'.  Furthermore, build programs---programs that run @code{./configure}, @code{make}, etc.---are written in Guile Scheme (@pxref{Derivations}).  Consequently, to be able to build anything at all, from scratch, Guix relies on pre-built binaries of Guile, GCC, Binutils, libc, and the other packages mentioned above---the @dfn{bootstrap binaries}."
msgstr "O sistema GNU é feito principalmente de código C, com libc em seu núcleo. O próprio sistema de construção GNU assume a disponibilidade de um Bourne shell e ferramentas de linha de comando fornecidas pelo GNU Coreutils, Awk, Findutils, `sed' e `grep'. Além disso, programas de construção --- programas que executam @code{./configure}, @code{make}, etc. --- são escritos em Guile Scheme (@pxref{Derivations}). Consequentemente, para ser capaz de construir qualquer coisa, do zero, Guix depende de binários pré-construídos de Guile, GCC, Binutils, libc e os outros pacotes mencionados acima --- os @dfn{binários bootstrap}."

msgid "These bootstrap binaries are ``taken for granted'', though we can also re-create them if needed (@pxref{Preparing to Use the Bootstrap Binaries})."
msgstr "Esses binários bootstrap são ``considerados garantidos'', embora também possamos recriá-los se necessário (@pxref{Preparing to Use the Bootstrap Binaries})."

msgid "The Full-Source Bootstrap"
msgstr "O Bootstrap de código fonte completo"

msgid "Guix---like other GNU/Linux distributions---is traditionally bootstrapped from a set of bootstrap binaries: Bourne shell, command-line tools provided by GNU Coreutils, Awk, Findutils, `sed', and `grep' and Guile, GCC, Binutils, and the GNU C Library (@pxref{Bootstrapping}).  Usually, these bootstrap binaries are ``taken for granted.''"
msgstr "Guix---como outras distribuições GNU/Linux---é tradicionalmente bootstrapado a partir de um conjunto de binários bootstrap: Bourne shell, ferramentas de linha de comando fornecidas pelo GNU Coreutils, Awk, Findutils, ``sed' e `grep' e Guile, GCC, Binutils e a GNU C Library (@pxref{Bootstrapping}). Normalmente, esses binários bootstrap são ``considerados garantidos.''"

msgid "Taking the bootstrap binaries for granted means that we consider them to be a correct and trustworthy ``seed'' for building the complete system.  Therein lies a problem: the combined size of these bootstrap binaries is about 250MB (@pxref{Bootstrappable Builds,,, mes, GNU Mes}).  Auditing or even inspecting these is next to impossible."
msgstr "Tomar os binários bootstrap como garantidos significa que os consideramos uma ``semente'' correta e confiável para construir o sistema completo. Aí está um problema: o tamanho combinado desses binários bootstrap é de cerca de 250 MB (@pxref{Bootstrappable Builds,,, mes, GNU Mes}). Auditar ou mesmo inspecionar isso é quase impossível."

msgid "For @code{i686-linux} and @code{x86_64-linux}, Guix now features a @dfn{full-source bootstrap}.  This bootstrap is rooted in @file{hex0-seed} from the @url{https://savannah.gnu.org/projects/stage0, Stage0} package.  The hex0 program is minimalist assembler: it reads space-separated hexadecimal digits (nibbles) from a file, possibly including comments, and emits on standard output the bytes corresponding to those hexadecimal numbers.  The source code of this initial hex0 program is a file called @url{https://github.com/oriansj/bootstrap-seeds/blob/master/POSIX/x86/hex0_x86.hex0,@file{hex0_x86.hex0}} and is written in the @code{hex0} language."
msgstr "Para @code{i686-linux} e @code{x86_64-linux}, o Guix agora apresenta um @dfn{full-source bootstrap}. Este bootstrap está enraizado em @file{hex0-seed} do pacote @url{https://savannah.gnu.org/projects/stage0, Stage0}. O programa hex0 é um assembler minimalista: ele lê dígitos hexadecimais separados por espaços (nibbles) de um arquivo, possivelmente incluindo comentários, e emite na saída padrão os bytes correspondentes a esses números hexadecimais. O código-fonte deste programa hex0 inicial é um arquivo chamado @url{https://github.com/oriansj/bootstrap-seeds/blob/master/POSIX/x86/hex0_x86.hex0,@file{hex0_x86.hex0}} e é escrito na linguagem @code{hex0}."

msgid "Hex0 is self-hosting, which means that it can build itself:"
msgstr "O Hex0 é auto-hospedado, o que significa que ele pode se construir:"

msgid "Hex0 it is the ASCII-equivalent of the binary program and can be produced by doing something much like:"
msgstr "Hex0 é o equivalente ASCII do programa binário e pode ser produzido fazendo algo muito parecido com:"

msgid "It is because of this ASCII-binary equivalence that we can bless this initial 357-byte binary as source, and hence `full-source bootstrap''."
msgstr "É por causa dessa equivalência ASCII-binário que podemos abençoar esse binário inicial de 357 bytes como fonte e, portanto, `bootstrap de fonte completa''."

msgid "The bootstrap then continues: @code{hex0} builds @code{hex1} and then on to @code{M0}, @code{hex2}, @code{M1}, @code{mescc-tools} and finally @code{M2-Planet}.  Then, using @code{mescc-tools}, @code{M2-Planet} we build Mes (@pxref{Top, GNU Mes Reference Manual,, mes, GNU Mes}, a Scheme interpreter and C compiler in Scheme).  From here on starts the more traditional @code{C}-based bootstrap of the GNU System."
msgstr "O bootstrap então continua: @code{hex0} constrói @code{hex1} e então para @code{M0}, @code{hex2}, @code{M1}, @code{mescc-tools} e finalmente @code{M2-Planet}. Então, usando @code{mescc-tools}, @code{M2-Planet} nós construímos Mes (@pxref{Top, GNU Mes Reference Manual,, mes, GNU Mes}, um interpretador Scheme e compilador C em Scheme). A partir daqui começa o bootstrap mais tradicional baseado em @code{C} do Sistema GNU."

msgid "Another step that Guix has taken is to replace the shell and all its utilities with implementations in Guile Scheme, the @emph{Scheme-only bootstrap}.  Gash (@pxref{Gash,,, gash, The Gash manual}) is a POSIX-compatible shell that replaces Bash, and it comes with Gash Utils which has minimalist replacements for Awk, the GNU Core Utilities, Grep, Gzip, Sed, and Tar."
msgstr "Outro passo que o Guix tomou foi substituir o shell e todos os seus utilitários por implementações no Guile Scheme, o @emph{Scheme-only bootstrap}. O Gash (@pxref{Gash,,, gash, The Gash manual}) é um shell compatível com POSIX que substitui o Bash, e vem com o Gash Utils, que tem substituições minimalistas para o Awk, o GNU Core Utilities, Grep, Gzip, Sed e Tar."

msgid "Building the GNU System from source is currently only possible by adding some historical GNU packages as intermediate steps@footnote{Packages such as @code{gcc-2.95.3}, @code{binutils-2.14}, @code{glibc-2.2.5}, @code{gzip-1.2.4}, @code{tar-1.22}, and some others.  For details, see @file{gnu/packages/commencement.scm}.}.  As Gash and Gash Utils mature, and GNU packages become more bootstrappable again (e.g., new releases of GNU Sed will also ship as gzipped tarballs again, as alternative to the hard to bootstrap @code{xz}-compression), this set of added packages can hopefully be reduced again."
msgstr "Atualmente, construir o Sistema GNU a partir do código-fonte só é possível adicionando alguns pacotes históricos do GNU como etapas intermediárias@footnote{Pacotes como @code{gcc-2.95.3}, @code{binutils-2.14}, @code{glibc-2.2.5}, @code{gzip-1.2.4}, @code{tar-1.22} e alguns outros. Para detalhes, veja @file{gnu/packages/commencement.scm}.}. Conforme o Gash e o Gash Utils amadurecem, e os pacotes GNU se tornam mais inicializáveis novamente (por exemplo, novos lançamentos do GNU Sed também serão enviados como tarballs compactados novamente, como alternativa à compressão @code{xz} difícil de inicializar), esse conjunto de pacotes adicionados pode ser reduzido novamente."

msgid "The graph below shows the resulting dependency graph for @code{gcc-core-mesboot0}, the bootstrap compiler used for the traditional bootstrap of the rest of the Guix System."
msgstr "O grafo abaixo mostra o grafo de dependência resultante para @code{gcc-core-mesboot0}, o compilador bootstrap usado para o bootstrap tradicional do restante do Sistema Guix."

msgid "Work is ongoing to bring these bootstraps to the @code{arm-linux} and @code{aarch64-linux} architectures and to the Hurd."
msgstr "O trabalho está em andamento para levar esses bootstraps às arquiteturas @code{arm-linux} e @code{aarch64-linux} e ao Hurd."

msgid "If you are interested, join us on @samp{#bootstrappable} on the Libera.Chat IRC network or discuss on @email{bug-mes@@gnu.org} or @email{gash-devel@@nongnu.org}."
msgstr "Se você estiver interessado, junte-se a nós em @samp{#bootstrappable} na rede IRC Libera.Chat ou discuta em @email{bug-mes@@gnu.org} ou @email{gash-devel@@nongnu.org}."

msgid "@image{images/bootstrap-graph,6in,,Dependency graph of the early bootstrap derivations}"
msgstr "@image{images/bootstrap-graph,6in,,Grafo de dependência das primeiras derivações do bootstrap}"

msgid "The figure above shows the very beginning of the dependency graph of the distribution, corresponding to the package definitions of the @code{(gnu packages bootstrap)} module.  A similar figure can be generated with @command{guix graph} (@pxref{Invoking guix graph}), along the lines of:"
msgstr "A figura acima mostra o início do grafo de dependência da distribuição, correspondendo às definições de pacote do módulo @code{(gnu packages bootstrap)}. Uma figura similar pode ser gerada com @command{guix graph} (@pxref{Invoking guix graph}), ao longo das linhas de:"

msgid "or, for the further Reduced Binary Seed bootstrap"
msgstr "ou, para o bootstrap de semente binária reduzida"

msgid ""
"guix graph -t derivation \\\n"
"  -e '(@@@@ (gnu packages bootstrap) %bootstrap-mes)' \\\n"
"  | dot -Tps > mes.ps\n"
msgstr ""
"guix graph -t derivation  \\\n"
"-e '(@@@@ (pacotes gnu bootstrap) %bootstrap-mes)' \\\n"
"| ponto -Tps > mes.ps\n"

msgid "At this level of detail, things are slightly complex.  First, Guile itself consists of an ELF executable, along with many source and compiled Scheme files that are dynamically loaded when it runs.  This gets stored in the @file{guile-2.0.7.tar.xz} tarball shown in this graph.  This tarball is part of Guix's ``source'' distribution, and gets inserted into the store with @code{add-to-store} (@pxref{The Store})."
msgstr "Neste nível de detalhe, as coisas são um pouco complexas. Primeiro, o próprio Guile consiste em um executável ELF, junto com muitas fontes e arquivos de Scheme compilados que são carregados dinamicamente quando ele é executado. Isso é armazenado no tarball @file{guile-2.0.7.tar.xz} mostrado neste grafo. Este tarball é parte da distribuição de ``fontes'' do Guix e é inserido no armazém com @code{add-to-store} (@pxref{The Store})."

msgid "But how do we write a derivation that unpacks this tarball and adds it to the store? To solve this problem, the @code{guile-bootstrap-2.0.drv} derivation---the first one that gets built---uses @code{bash} as its builder, which runs @code{build-bootstrap-guile.sh}, which in turn calls @code{tar} to unpack the tarball.  Thus, @file{bash}, @file{tar}, @file{xz}, and @file{mkdir} are statically-linked binaries, also part of the Guix source distribution, whose sole purpose is to allow the Guile tarball to be unpacked."
msgstr "Mas como escrevemos uma derivação que descompacta esse tarball e o adiciona ao armazém? Para resolver esse problema, a derivação @code{guile-bootstrap-2.0.drv} --- a primeira que é construída --- usa @code{bash} como seu construtor, que executa @code{build-bootstrap-guile.sh}, que por sua vez chama @code{tar} para descompactar o tarball. Assim, @file{bash}, @file{tar}, @file{xz} e @file{mkdir} são binários estaticamente vinculados, também parte da distribuição de fontes do Guix, cujo único propósito é permitir que o tarball do Guile seja descompactado."

msgid "Once @code{guile-bootstrap-2.0.drv} is built, we have a functioning Guile that can be used to run subsequent build programs.  Its first task is to download tarballs containing the other pre-built binaries---this is what the @file{.tar.xz.drv} derivations do.  Guix modules such as @code{ftp-client.scm} are used for this purpose.  The @code{module-import.drv} derivations import those modules in a directory in the store, using the original layout.  The @code{module-import-compiled.drv} derivations compile those modules, and write them in an output directory with the right layout.  This corresponds to the @code{#:modules} argument of @code{build-expression->derivation} (@pxref{Derivations})."
msgstr "Uma vez que @code{guile-bootstrap-2.0.drv} é construído, temos um Guile funcional que pode ser usado para executar programas de construção subsequentes. Sua primeira tarefa é baixar tarballs contendo os outros binários pré-construídos --- é isso que as derivações @file{.tar.xz.drv} fazem. Módulos Guix como @code{ftp-client.scm} são usados para esse propósito. As derivações @code{module-import.drv} importam esses módulos em um diretório no armazém, usando o layout original. As derivações @code{module-import-compiled.drv} compilam esses módulos e os escrevem em um diretório de saída com o layout correto. Isso corresponde ao argumento @code{#:modules} de @code{build-expression->derivation} (@pxref{Derivations})."

msgid "Finally, the various tarballs are unpacked by the derivations @code{gcc-bootstrap-0.drv}, @code{glibc-bootstrap-0.drv}, or @code{bootstrap-mes-0.drv} and @code{bootstrap-mescc-tools-0.drv}, at which point we have a working C tool chain."
msgstr "Por fim, os vários tarballs são descompactados pelas derivações @code{gcc-bootstrap-0.drv}, @code{glibc-bootstrap-0.drv} ou @code{bootstrap-mes-0.drv} e @code{bootstrap-mescc-tools-0.drv}, ponto em que temos uma cadeia de ferramentas C funcional."

msgid "Building the Build Tools"
msgstr "Construindo as ferramentas de construção"

msgid "Bootstrapping is complete when we have a full tool chain that does not depend on the pre-built bootstrap tools discussed above.  This no-dependency requirement is verified by checking whether the files of the final tool chain contain references to the @file{/gnu/store} directories of the bootstrap inputs.  The process that leads to this ``final'' tool chain is described by the package definitions found in the @code{(gnu packages commencement)} module."
msgstr "O bootstrapping está completo quando temos uma cadeia de ferramentas completa que não depende das ferramentas bootstrap pré-construídas discutidas acima. Esse requisito de não dependência é verificado verificando se os arquivos da cadeia de ferramentas final contêm referências aos diretórios @file{/gnu/store} das entradas bootstrap. O processo que leva a essa cadeia de ferramentas ``final'' é descrito pelas definições de pacote encontradas no módulo @code{(gnu packages commencement)}."

msgid "The @command{guix graph} command allows us to ``zoom out'' compared to the graph above, by looking at the level of package objects instead of individual derivations---remember that a package may translate to several derivations, typically one derivation to download its source, one to build the Guile modules it needs, and one to actually build the package from source.  The command:"
msgstr "O comando @command{guix graph} nos permite ``diminuir o zoom'' em comparação ao grafo acima, observando o nível de objetos do pacote em vez de derivações individuais --- lembre-se de que um pacote pode ser traduzido para várias derivações, normalmente uma derivação para baixar sua fonte, uma para construir os módulos Guile de que ele precisa e uma para realmente construir o pacote a partir da fonte. O comando:"

msgid ""
"guix graph -t bag \\\n"
"  -e '(@@@@ (gnu packages commencement)\n"
"          glibc-final-with-bootstrap-bash)' | xdot -\n"
msgstr ""
"guix graph -t bag \\\n"
"  -e '(@@@@ (gnu packages commencement)\n"
"          glibc-final-with-bootstrap-bash)' | xdot -\n"

msgid "displays the dependency graph leading to the ``final'' C library@footnote{You may notice the @code{glibc-intermediate} label, suggesting that it is not @emph{quite} final, but as a good approximation, we will consider it final.}, depicted below."
msgstr "exibe o grafo de dependência que leva à biblioteca C ``final''@footnote{Você pode notar o rótulo @code{glibc-intermediate}, sugerindo que ela não é @emph{completamente} final, mas como uma boa aproximação, a consideraremos final.}, descrita abaixo."

msgid "@image{images/bootstrap-packages,6in,,Dependency graph of the early packages}"
msgstr "@image{images/bootstrap-packages,6in,,Grafo de dependência dos primeiros pacotes}"

msgid "The first tool that gets built with the bootstrap binaries is GNU@tie{}Make---noted @code{make-boot0} above---which is a prerequisite for all the following packages.  From there Findutils and Diffutils get built."
msgstr "A primeira ferramenta que é construída com os binários bootstrap é o GNU@tie{}Make---observado @code{make-boot0} acima---que é um pré-requisito para todos os pacotes seguintes. A partir daí, Findutils e Diffutils são construídos."

msgid "Then come the first-stage Binutils and GCC, built as pseudo cross tools---i.e., with @option{--target} equal to @option{--host}.  They are used to build libc.  Thanks to this cross-build trick, this libc is guaranteed not to hold any reference to the initial tool chain."
msgstr "Então vêm os Binutils e GCC de primeiro estágio, construídos como pseudo cross tools---i.e., com @option{--target} igual a @option{--host}. Eles são usados para construir a libc. Graças a esse truque de cross-build, essa libc tem a garantia de não manter nenhuma referência à cadeia de ferramentas inicial."

msgid "From there the final Binutils and GCC (not shown above) are built.  GCC uses @command{ld} from the final Binutils, and links programs against the just-built libc.  This tool chain is used to build the other packages used by Guix and by the GNU Build System: Guile, Bash, Coreutils, etc."
msgstr "A partir daí, os Binutils finais e o GCC (não mostrados acima) são construídos. O GCC usa @command{ld} dos Binutils finais e vincula programas à libc recém-construída. Essa cadeia de ferramentas é usada para construir os outros pacotes usados pelo Guix e pelo GNU Build System: Guile, Bash, Coreutils, etc."

msgid "And voilà! At this point we have the complete set of build tools that the GNU Build System expects.  These are in the @code{%final-inputs} variable of the @code{(gnu packages commencement)} module, and are implicitly used by any package that uses @code{gnu-build-system} (@pxref{Build Systems, @code{gnu-build-system}})."
msgstr "E voilà! Neste ponto, temos o conjunto completo de ferramentas de construção que o GNU Build System espera. Elas estão na variável @code{%final-inputs} do módulo @code{(gnu packages commencement)} e são implicitamente usadas por qualquer pacote que use @code{gnu-build-system} (@pxref{Build Systems, @code{gnu-build-system}})."

msgid "Building the Bootstrap Binaries"
msgstr "Construindo os binários Bootstrap"

msgid "Porting to a New Platform"
msgstr "Portando para uma nova plataforma"

msgid "guix build --target=armv5tel-linux-gnueabi bootstrap-tarballs\n"
msgstr "guix build --target=armv5tel-linux-gnueabi bootstrap-tarballs\n"

msgid "contributing.texi"
msgstr "contributing.pt_BR.texi"

msgid "Guix is based on the @uref{https://nixos.org/nix/, Nix package manager}, which was designed and implemented by Eelco Dolstra, with contributions from other people (see the @file{nix/AUTHORS} file in Guix).  Nix pioneered functional package management, and promoted unprecedented features, such as transactional package upgrades and rollbacks, per-user profiles, and referentially transparent build processes.  Without this work, Guix would not exist."
msgstr "Guix é baseado no @uref{https://nixos.org/nix/, gerenciador de pacotes Nix}, que foi projetado e implementado por Eelco Dolstra, com contribuições de outras pessoas (veja o arquivo @file{nix/AUTHORS} no Guix.) O Nix foi pioneiro no gerenciamento funcional de pacotes e promoveu recursos sem precedentes, como atualizações e reversões de pacotes transacionais, perfis por usuário e processos de construção referencialmente transparentes. Sem esse trabalho, o Guix não existiria."

msgid "The Nix-based software distributions, Nixpkgs and NixOS, have also been an inspiration for Guix."
msgstr "As distribuições de software baseadas em Nix, Nixpkgs e NixOS, também foram uma inspiração para o Guix."

msgid "GNU@tie{}Guix itself is a collective work with contributions from a number of people.  See the @file{AUTHORS} file in Guix for more information on these fine people.  The @file{THANKS} file lists people who have helped by reporting bugs, taking care of the infrastructure, providing artwork and themes, making suggestions, and more---thank you!"
msgstr "O GNU@tie{}Guix em si é um trabalho coletivo com contribuições de várias pessoas. Veja o arquivo @file{AUTHORS} no Guix para obter mais informações sobre essas pessoas legais. O arquivo @file{THANKS} lista as pessoas que ajudaram a relatar erros, cuidar da infraestrutura, fornecer ilustrações e temas, fazer sugestões e muito mais -- obrigado!"

msgid "license, GNU Free Documentation License"
msgstr "licença, Licença de Documentação Livre GNU"

msgid "fdl-1.3.texi"
msgstr "fdl-1.3.texi"
