guix manual checkout - en to pt_BR translation catalogue (814 entries)

note: #-#-#-#-#  contributing.pot (guix manual checkout)  #-#-#-#-# type: chapter #-#-#-#-#  guix.pot (guix manual checkout)  #-#-#-#-# type: menuentry
en: Contributing
pt_BR: Contribuindo

note: type: cindex
en: code of conduct, of contributors
pt_BR: código de conduta, de contribuidores

note: type: cindex
en: contributor covenant
pt_BR: acordo de contribuição

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: section
en: Building from Git
pt_BR: Compilando do git

note: type: menuentry
en: The latest and greatest.
pt_BR: A mais recente e melhor.

note: type: section
en: Running Guix Before It Is Installed
pt_BR: Executando guix antes dele ser instalado

note: type: menuentry
en: Hacker tricks.
pt_BR: Truques de hacker.

note: type: section
en: The Perfect Setup
pt_BR: A configuração perfeita

note: type: menuentry
en: The right tools.
pt_BR: As ferramentas certas.

note: type: section
en: Packaging Guidelines
pt_BR: Diretrizes de empacotamento

note: type: menuentry
en: Growing the distribution.
pt_BR: Crescendo a distribuição.

note: type: section
en: Coding Style
pt_BR: Estilo de código

note: type: menuentry
en: Hygiene of the contributor.
pt_BR: Limpeza do contribuidor.

note: type: section
en: Submitting Patches
pt_BR: Enviando patches

note: type: menuentry
en: Share your work.
pt_BR: Compartilhe seu trabalho.

note: type: section
en: Translating Guix
pt_BR: Traduzindo o Guix

note: type: Plain text
en: If you want to hack Guix itself, it is recommended to use the latest version from the Git repository:
pt_BR: Se você quiser hackear o próprio Guix, é recomendado usar a versão mais recente do repositório Git:

note: type: Plain text
en: 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:
pt_BR: A maneira mais fácil de configurar um ambiente de desenvolvimento para o Guix é, obviamente, usando o Guix! O comando a seguir inicia um novo shell no qual todas as dependências e variáveis de ambiente apropriadas são configuradas para hackear o Guix:

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: @xref{Macro Search Path,,, automake, The GNU Automake Manual}, for more information.
pt_BR: @xref{Macro Search Path,,, automake, The GNU Automake Manual}, para mais informações.

note: type: quotation
en: Note
pt_BR: Nota

note: type: Plain text
en: 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.
pt_BR: 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''.

note: type: Plain text
en: The @command{pre-inst-env} script sets up all the environment variables necessary to support this, including @env{PATH} and @env{GUILE_LOAD_PATH}.
pt_BR: 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}.

note: type: Plain text
en: 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.
pt_BR: Observe que @command{./pre-inst-env guix pull} @emph{não} atualiza a área de fontes local; ele simplesmente atualiza o link simbólico @file{~/.config/guix/current} (@pxref{Invocando guix pull}). Execute @command{git pull} em vez disso, se você quiser atualizar sua árvore de fontes local.

note: type: Plain text
en: 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}).  For convenient Guix development, make sure to augment Guile’s load path so that it finds source files from your checkout:
pt_BR: O Geiser permite um desenvolvimento interativo e incremental de dentro do Emacs: compilação e avaliação de código de dentro dos buffers, acesso à documentação on-line (docstrings), completação sensível ao contexto, @kbd{M-.} para pular para uma definição de objeto, um REPL para tentar seu código e muito mais (@pxref{Introdução ,,, geiser, Manual de usuário do Geiser}). Para um desenvolvimento prático do Guix, certifique-se de aumentar o caminho de carregamento do Guile para que ele encontre os arquivos de origem do seu checkout:

note: type: lisp
en: ;; @r{Assuming the Guix checkout is in ~/src/guix.}
    (with-eval-after-load 'geiser-guile
      (add-to-list 'geiser-guile-load-path "~/src/guix"))
pt_BR: ;; @r{Presumindo que o checkout do Guix está em ~/src/guix.}
    (with-eval-after-load 'geiser-guile
      (add-to-list 'geiser-guile-load-path "~/src/guix"))

note: type: cindex
en: code snippets
pt_BR: trechos de código

note: type: cindex
en: templates
pt_BR: modelos

note: type: cindex
en: reducing boilerplate
pt_BR: reduzindo boilerplate

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: cindex
en: packages, creating
pt_BR: pacotes, criação

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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}.
pt_BR: 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{Módulos de pacote}). 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{Definindo pacotes}.

note: type: Plain text
en: 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}):
pt_BR: 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{Invocando 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{Executando guix antes dele ser instalado}):

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: cindex
en: substituter
pt_BR: substituidor

note: type: subsection
en: Software Freedom
pt_BR: Liberdade de software

note: type: menuentry
en: What may go into the distribution.
pt_BR: O que pode ir na distribuição.

note: type: subsection
en: Package Naming
pt_BR: Nomeando um pacote

note: type: menuentry
en: What's in a name?
pt_BR: Que há em um nome?

note: type: subsection
en: Version Numbers
pt_BR: Números de versão

note: type: menuentry
en: When the name is not enough.
pt_BR: Quando o nome não é suficiente.

note: type: subsection
en: Synopses and Descriptions
pt_BR: Sinopses e descrições

note: type: menuentry
en: Helping users find the right package.
pt_BR: Ajudando usuários a localizar o pacote certo.

note: type: subsection
en: Python Modules
pt_BR: Módulos Python

note: type: menuentry
en: A touch of British comedy.
pt_BR: Um toque de comédia britânica.

note: type: subsection
en: Perl Modules
pt_BR: Módulos Perl

note: type: menuentry
en: Little pearls.
pt_BR: Pequenas pérolas.

note: type: subsection
en: Java Packages
pt_BR: Pacotes Java

note: type: menuentry
en: Coffee break.
pt_BR: Parada para o café.

note: type: subsection
en: Fonts
pt_BR: Fontes

note: type: menuentry
en: Fond of fonts.
pt_BR: Vício em fontes.

note: type: cindex
en: free software
pt_BR: software livre

note: type: Plain text
en: 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.
pt_BR: 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{Definindo pacotes}). Dessa forma, o @code{guix build --source} retorna a fonte ``lançada'' em vez da fonte upstream não modificada.

note: type: cindex
en: package name
pt_BR: nome de pacote

note: type: Plain text
en: 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}.
pt_BR: 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}.

note: type: Plain text
en: 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.
pt_BR: 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{Módulos Python} e @ref{Módulos Perl} para regras especiais relativas a módulos para as linguagens Python e Perl.

note: type: Plain text
en: Font package names are handled differently, @pxref{Fonts}.
pt_BR: Nomes de pacote de fontes são lidados de forma diferente. @xref{Fontes}.

note: type: cindex
en: package version
pt_BR: versão de pacote

note: type: Plain text
en: 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.
pt_BR: 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{Nomeando um pacote} 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.

note: type: Plain text
en: The name inside the package definition is the same for all versions of a package and does not contain any version number.
pt_BR: 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.

note: type: Plain text
en: For instance, the versions 2.24.20 and 3.9.12 of GTK+ may be packaged as follows:
pt_BR: Por exemplo, as versões 2.24.20 e 3.9.12 do GTK podem ser empacotados da seguinte forma:

note: type: Plain text
en: If we also wanted GTK+ 3.8.2, this would be packaged as
pt_BR: Se também quiséssemos GTK 3.8.2, este seria empacotado como

note: type: cindex
en: version number, for VCS snapshots
pt_BR: número de versão, para snapshots de VCS

note: type: Plain text
en: 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?
pt_BR: 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}?

note: type: Plain text
en: 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:
pt_BR: 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{pacote guix --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:

note: type: example
en: 2.0.11-3.cabba9e
      ^    ^    ^
      |    |    `-- upstream commit ID
      |    |
      |    `--- Guix package revision
      |
    latest upstream version
pt_BR: 2.0.11-3.cabba9e
      ^    ^    ^
      |    |    `-- ID do commit do upstream
      |    |
      |    `--- revisão do pacote do Guix
      |
    versão mais recente do upstream

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

note: type: cindex
en: package description
pt_BR: descrição do pacote

note: type: cindex
en: package synopsis
pt_BR: sinopse do pacote

note: type: Plain text
en: 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.
pt_BR: Como vimos anteriormente, cada pacote no GNU@tie{}Guix inclui uma sinopse e uma descrição (@pxref{Definindo pacotes}). 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.

note: type: Plain text
en: 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''.
pt_BR: 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''.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: cindex
en: Texinfo markup, in package descriptions
pt_BR: Marcação Texinfo, em descrições de pacote

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: lisp
en: (package
      ;; @dots{}
      (synopsis "This is translatable")
      (description (string-append "This is " "*not*" " translatable.")))
pt_BR: (package
      ;; @dots{}
      (synopsis "Isso é traduzível")
      (description (string-append "Isso " "*não*" " é traduzível.")))

note: type: Plain text
en: 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}):
pt_BR: 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}):

note: type: Plain text
en: We currently package Python 2 and Python 3, under the Scheme variable names @code{python-2} and @code{python} as explained in @ref{Version Numbers}.  To avoid confusion and naming clashes with other programming languages, it seems desirable that the name of a package for a Python module contains the word @code{python}.
pt_BR: Atualmente empacotamos Python 2 e Python 3, sob os nomes de variável Scheme @code{python-2} e @code{python} conforme explicado em @ref{Números de versão}.  Para evitar confusão e conflitos de nomes com outras linguagens de programação, parece desejável que o nome de um pacote para um módulo Python contenha a palavra @code{python}.

note: type: Plain text
en: If a project already contains the word @code{python}, we drop this; for instance, the module python-dateutil is packaged under the names @code{python-dateutil} and @code{python2-dateutil}.  If the project name starts with @code{py} (e.g.@: @code{pytz}), we keep it and prefix it as described above.
pt_BR: Se um projeto já contém a palavra @code{python}, nós a descartamos; por exemplo, o módulo python-dateutil é empacotado sob os nomes @code{python-dateutil} e @code{python2-dateutil}. Se o nome do projeto começa com @code{py} (p.ex., @code{pytz}), nós o mantemos e o prefixamos conforme descrito acima.

note: type: subsubsection
en: Specifying Dependencies
pt_BR: Especificando dependências

note: type: cindex
en: inputs, for Python packages
pt_BR: entradas, para pacotes Python

note: type: Plain text
en: Your mission, when writing a recipe for a Python package, is to map these dependencies to the appropriate type of ``input'' (@pxref{package Reference, inputs}).  Although the @code{pypi} importer normally does a good job (@pxref{Invoking guix import}), you may want to check the following check list to determine which dependency goes where.
pt_BR: Sua missão, ao escrever uma receita para um pacote Python, é mapear essas dependências para o tipo apropriado de ``entrada'' (@pxref{Referência do package, inputs}). Apesar do importador do @code{pypi} normalmente fazer um bom trabalho (@pxref{Invocando guix import}), você pode se interessar em verificar a lista de verificação a seguir para determinar qual dependência vai onde.

note: type: itemize
en: 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.
pt_BR: 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}.

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

note: type: itemize
en: 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.
pt_BR: 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.

note: type: itemize
en: 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}}).
pt_BR: 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{Enviando patches, @command{guix size}}).

note: type: Plain text
en: 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}.
pt_BR: 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}.

note: type: Plain text
en: Java programs standing for themselves are named as any other package, using the lowercase upstream name.
pt_BR: Os programas Java próprios são nomeados como qualquer outro pacote, usando o nome do upstream em letras minúsculas.

note: type: Plain text
en: 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}.
pt_BR: 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}.

note: type: Plain text
en: 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}.
pt_BR: 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}.

note: type: cindex
en: fonts
pt_BR: fontes

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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}.
pt_BR: 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}.

note: type: Plain text
en: 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}.
pt_BR: 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}.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: subsection
en: Programming Paradigm
pt_BR: Paradigma de programação

note: type: menuentry
en: How to compose your elements.
pt_BR: Como compor seus elementos.

note: type: subsection
en: Modules
pt_BR: Módulos

note: type: menuentry
en: Where to store your code?
pt_BR: Onde armazenar seu código?

note: type: subsection
en: Data Types and Pattern Matching
pt_BR: Tipos de dados e correspondência de padrão

note: type: menuentry
en: Implementing data structures.
pt_BR: Implementação de estruturas de dados.

note: type: subsection
en: Formatting Code
pt_BR: Formatação de código

note: type: menuentry
en: Writing conventions.
pt_BR: Convenções de escrita.

note: type: Plain text
en: 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.
pt_BR: 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}.

note: type: Plain text
en: 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.
pt_BR: Os módulos de 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 do lado do compilador.

note: type: Plain text
en: Modules that deal with the broader GNU system should be in the @code{(gnu @dots{})} name space rather than @code{(guix @dots{})}.
pt_BR: 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{})}.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: cindex
en: formatting code
pt_BR: formatação de código

note: type: cindex
en: coding style
pt_BR: estilo de codificação

note: type: Plain text
en: 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}).
pt_BR: 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}).

note: type: cindex
en: indentation, of code
pt_BR: recuo, de código

note: type: cindex
en: formatting, of code
pt_BR: formatação, de código

note: type: Plain text
en: If you do not use Emacs, please make sure to let your editor knows these rules.  To automatically indent a package definition, you can also run:
pt_BR: 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:

note: type: cindex
en: Vim, Scheme code editing
pt_BR: Vim, edição de código Scheme

note: type: Plain text
en: If you are editing code with Vim, we recommend that you run @code{:set autoindent} so that your code is automatically indented as you type.  Additionally, @uref{https://www.vim.org/scripts/script.php?script_id=3998, @code{paredit.vim}} may help you deal with all these parentheses.
pt_BR: Se você estiver editando código com o Vim, recomendamos que execute @code{:set autoindent} para que seu código seja automaticamente recuado na medida em que você digita. Além disso, o @uref{https://www.vim.org/scripts/script.php?script_id=3998, @code{paredit.vim}} pode ajudá-lo a lidar com todos esses parênteses.

note: type: Plain text
en: 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.
pt_BR: 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{})}.

note: type: Plain text
en: Procedures should not have more than four positional parameters.  Use keyword parameters for procedures that take more than four parameters.
pt_BR: 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.

note: type: Plain text
en: Please write commit logs in the ChangeLog format (@pxref{Change Logs,,, standards, GNU Coding Standards}); you can check the commit history for examples.
pt_BR: 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.

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

note: type: enumerate
en: 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.
pt_BR: 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}.

note: type: enumerate
en: Take some time to provide an adequate synopsis and description for the package.  @xref{Synopses and Descriptions}, for some guidelines.
pt_BR: Reserve algum tempo para fornecer uma sinopse e descrição adequadas para o pacote. @xref{Sinopses e descrições}, para algumas diretrizes.

note: type: enumerate
en: Run @code{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}).
pt_BR: Execute @code{guix lint @var{pacote}}, sendo @var{pacote} o nome do pacote novo ou modificado e corrija quaisquer erros que forem relatados (@pxref{Invocando guix lint}).

note: type: enumerate
en: Make sure the package builds on your platform, using @code{guix build @var{package}}.
pt_BR: Certifique-se de que o pacote compila em sua plataforma, usando @code{guix build @var{pacote}}.

note: type: enumerate
en: Then reconfigure your system.
pt_BR: Então, reconfigure seu sistema.

note: type: cindex
en: bundling
pt_BR: incorporando

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

note: type: enumerate
en: 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.
pt_BR: À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.

note: type: cindex
en: branching strategy
pt_BR: estratégia de ramificação

note: type: cindex
en: rebuild scheduling strategy
pt_BR: estratégia de agendamento de recompilação

note: type: enumerate
en: Depending on the number of dependent packages and thus the amount of rebuilding induced, commits go to different branches, along these lines:
pt_BR: Dependendo do número de pacotes dependentes e, portanto, da quantidade de recompilação induzida, os commits vão para diferentes ramos, ao longo das seguintes linhas:

note: type: item
en: 300 dependent packages or less
pt_BR: 300 pacotes dependentes ou menos

note: type: table
en: @code{master} branch (non-disruptive changes).
pt_BR: Ramo @code{master} (alterações não disruptivas).

note: type: cindex
en: determinism, of build processes
pt_BR: determinismo, de processos de compilação

note: type: cindex
en: reproducible builds, checking
pt_BR: compilações reproduzíveis, verificação

note: type: enumerate
en: 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.
pt_BR: 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.

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

note: type: example
en: guix build --rounds=2 my-package
pt_BR: guix build --rounds=2 meu-pacote

note: type: enumerate
en: This is enough to catch a class of common non-determinism issues, such as timestamps or randomly-generated output in the build result.
pt_BR: 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.

note: type: enumerate
en: 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.
pt_BR: 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.

note: type: enumerate
en: Verify that your patch contains only one set of related changes.  Bundling unrelated changes together makes reviewing harder and slower.
pt_BR: 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.

note: type: enumerate
en: Examples of unrelated changes include the addition of several packages, or a package update along with fixes to that package.
pt_BR: 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.

note: type: enumerate
en: 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 @command{name} field in the URL: it is not very useful and if the name changes, the URL will probably be wrong.
pt_BR: Quando possível, use espelhos no URL fonte (@pxref{Invocando 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 @command{name} no URL: não é muito útil e se o nome mudar, o URL provavelmente estará errado.

note: type: subsection
en: Configuring Git
pt_BR: Configurando o Git

note: type: cindex
en: git configuration
pt_BR: Configuração do git

note: type: subsection
en: Sending a Patch Series
pt_BR: Enviando uma série de patches

note: type: cindex
en: patch series
pt_BR: série de patches

note: type: quotation
en: Important
pt_BR: Importante

note: type: cindex
en: translation
pt_BR: tradução

note: #-#-#-#-#  contributing.pot (guix manual checkout)  #-#-#-#-# type: item #-#-#-#-#  guix.pot (guix manual checkout)  #-#-#-#-# type: cindex
en: packages
pt_BR: pacotes

note: type: title
en: GNU Guix Reference Manual
pt_BR: Manual de referência do GNU Guix

note: type: include
en: version.texi
pt_BR: version-pt_BR.texi

note: type: copying
en: 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''.
pt_BR: 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''.

note: type: dircategory
en: System administration
pt_BR: Administração de Sistemas

note: type: menuentry
en: Manage installed software and system configuration.
pt_BR: Gerencie softwares instalados e configuração do sistema.

note: type: menuentry
en: guix package: (guix)Invoking guix package
pt_BR: guix package: (guix)Invocando guix package

note: type: menuentry
en: Installing, removing, and upgrading packages.
pt_BR: Instalando, removendo e atualizando pacotes.

note: type: menuentry
en: guix gc: (guix)Invoking guix gc
pt_BR: guix gc: (guix)Invocando guix gc

note: type: menuentry
en: Reclaiming unused disk space.
pt_BR: Recuperando espaço em disco não utilizado.

note: type: menuentry
en: guix pull: (guix)Invoking guix pull
pt_BR: guix pull: (guix)Invocando guix pull

note: type: menuentry
en: Update the list of available packages.
pt_BR: Atualize a lista de pacotes disponíveis.

note: type: menuentry
en: guix system: (guix)Invoking guix system
pt_BR: guix system: (guix)Invocando guix system

note: type: menuentry
en: Manage the operating system configuration.
pt_BR: Gerencie a configuração do sistema operacional.

note: type: dircategory
en: Software development
pt_BR: Desenvolvimento de software

note: type: menuentry
en: guix environment: (guix)Invoking guix environment
pt_BR: guix environment: (guix)Invocando guix environment

note: type: menuentry
en: Building development environments with Guix.
pt_BR: Compilando ambientes de desenvolvimento com Guix.

note: type: menuentry
en: guix build: (guix)Invoking guix build
pt_BR: guix build: (guix)Invocando guix build

note: type: menuentry
en: Building packages.
pt_BR: Compilando pacotes.

note: type: menuentry
en: guix pack: (guix)Invoking guix pack
pt_BR: guix pack: (guix)Invocando guix pack

note: type: menuentry
en: Creating binary bundles.
pt_BR: Criando pacotes de binários.

note: type: subtitle
en: Using the GNU Guix Functional Package Manager
pt_BR: Usando o Gerenciador de Pacotes Funcional GNU Guix

note: type: author
en: The GNU Guix Developers
pt_BR: Os desenvolvedores do GNU Guix

note: type: titlepage
en: Edition @value{EDITION} @* @value{UPDATED} @*
pt_BR: Edição @value{EDITION} @* @value{UPDATED} @*

note: type: Plain text
en: This document describes GNU Guix version @value{VERSION}, a functional package management tool written for the GNU system.
pt_BR: Esse documento descreve Guix versão @value{VERSION}, uma ferramenta de gerenciamento de pacotes funcional escrita para o sistema GNU.

note: type: chapter
en: Introduction
pt_BR: Introdução

note: type: menuentry
en: What is Guix about?
pt_BR: Sobre o que é o Guix?

note: type: chapter
en: Installation
pt_BR: Instalação

note: type: menuentry
en: Installing Guix.
pt_BR: Instalando o Guix.

note: type: chapter
en: System Installation
pt_BR: Instalação do sistema

note: type: menuentry
en: Installing the whole operating system.
pt_BR: Instalando todo o sistema operacional.

note: type: chapter
en: Getting Started
pt_BR: Primeiros passos

note: type: chapter
en: Package Management
pt_BR: Gerenciamento de pacote

note: type: menuentry
en: Package installation, upgrade, etc.
pt_BR: Instalação de pacote, atualização, etc.

note: type: chapter
en: Channels
pt_BR: Canais

note: type: menuentry
en: Customizing the package collection.
pt_BR: Personalizando a coleção de pacotes.

note: type: chapter
en: Development
pt_BR: Desenvolvimento

note: type: menuentry
en: Guix-aided software development.
pt_BR: Desenvolvimento de software auxiliado pelo Guix.

note: type: chapter
en: Programming Interface
pt_BR: Interface de programação

note: type: menuentry
en: Using Guix in Scheme.
pt_BR: Usando o Guix no Scheme.

note: type: chapter
en: Utilities
pt_BR: Utilitários

note: type: menuentry
en: Package management commands.
pt_BR: Comandos de gerenciamento de pacote.

note: type: chapter
en: System Configuration
pt_BR: Configuração do sistema

note: type: menuentry
en: Configuring the operating system.
pt_BR: Configurando o sistema operacional.

note: type: chapter
en: Documentation
pt_BR: Documentação

note: type: menuentry
en: Browsing software user manuals.
pt_BR: Navegando por manuais do usuário do software.

note: type: chapter
en: Installing Debugging Files
pt_BR: Instalando arquivos de depuração

note: type: menuentry
en: Feeding the debugger.
pt_BR: Alimentando o depurador.

note: type: chapter
en: Security Updates
pt_BR: Atualizações de segurança

note: type: menuentry
en: Deploying security fixes quickly.
pt_BR: Implementando correções de segurança rapidamente.

note: type: chapter
en: Bootstrapping
pt_BR: Inicializando

note: type: menuentry
en: GNU/Linux built from scratch.
pt_BR: GNU/Linux compilado do zero.

note: type: node
en: Porting
pt_BR: Portando

note: type: menuentry
en: Targeting another platform or kernel.
pt_BR: Objetivando outra plataforma ou kernel.

note: type: menuentry
en: Your help needed!
pt_BR: Sua ajuda é necessária!

note: type: chapter
en: Acknowledgments
pt_BR: Agradecimentos

note: type: menuentry
en: Thanks!
pt_BR: Obrigado!

note: type: appendix
en: GNU Free Documentation License
pt_BR: Licença de Documentação Livre GNU

note: type: menuentry
en: The license of this manual.
pt_BR: A licença deste manual.

note: type: unnumbered
en: Concept Index
pt_BR: Índice de conceitos

note: type: menuentry
en: Concepts.
pt_BR: Conceitos.

note: type: unnumbered
en: Programming Index
pt_BR: Índice de programação

note: type: menuentry
en: Data types, functions, and variables.
pt_BR: Tipos de dados, funções e variáveis.

note: type: menuentry
en: --- The Detailed Node Listing ---
pt_BR: --- A listagem detalhada de nós ---

note: type: section
en: Managing Software the Guix Way
pt_BR: Gerenciando software do jeito do Guix

note: type: menuentry
en: What's special.
pt_BR: O que há de especial.

note: type: section
en: GNU Distribution
pt_BR: Distribuição GNU

note: type: menuentry
en: The packages and tools.
pt_BR: Os pacotes e as ferramentas.

note: type: section
en: Binary Installation
pt_BR: Instalação de binários

note: type: menuentry
en: Getting Guix running in no time!
pt_BR: Faça o Guix funcionar rapidamente!

note: type: section
en: Requirements
pt_BR: Requisitos

note: type: menuentry
en: Software needed to build and run Guix.
pt_BR: Software necessário para compilar e executar o Guix.

note: type: section
en: Running the Test Suite
pt_BR: Executando a suíte de testes

note: type: menuentry
en: Testing Guix.
pt_BR: Testando o Guix.

note: type: section
en: Setting Up the Daemon
pt_BR: Configurando o daemon

note: type: menuentry
en: Preparing the build daemon's environment.
pt_BR: Preparando o ambiente do daemon de compilação.

note: type: node
en: Invoking guix-daemon
pt_BR: Invocando guix-daemon

note: type: menuentry
en: Running the build daemon.
pt_BR: Executando o daemon de compilação.

note: type: section
en: Application Setup
pt_BR: Configuração de aplicativo

note: type: menuentry
en: Application-specific setup.
pt_BR: Configuração específica de aplicativo.

note: type: subsection
en: Build Environment Setup
pt_BR: Configuração do ambiente de compilação

note: type: menuentry
en: Preparing the isolated build environment.
pt_BR: Preparando o ambiente de compilação isolado.

note: type: node
en: Daemon Offload Setup
pt_BR: Configuração de descarregamento de daemon

note: type: menuentry
en: Offloading builds to remote machines.
pt_BR: Descarregando compilações para máquinas remotas.

note: type: subsection
en: SELinux Support
pt_BR: Suporte a SELinux

note: type: menuentry
en: Using an SELinux policy for the daemon.
pt_BR: Usando um política SELinux para o daemon.

note: type: section
en: Limitations
pt_BR: Limitações

note: type: menuentry
en: What you can expect.
pt_BR: O que você pode esperar.

note: type: section
en: Hardware Considerations
pt_BR: Considerações de hardware

note: type: menuentry
en: Supported hardware.
pt_BR: Hardware suportado.

note: type: section
en: USB Stick and DVD Installation
pt_BR: Instalação em um pendrive e em DVD

note: type: menuentry
en: Preparing the installation medium.
pt_BR: Preparando a mídia de instalação.

note: type: section
en: Preparing for Installation
pt_BR: Preparando para instalação

note: type: menuentry
en: Networking, partitioning, etc.
pt_BR: Rede, particionamento, etc.

note: type: section
en: Guided Graphical Installation
pt_BR: Instalação gráfica guiada

note: type: menuentry
en: Easy graphical installation.
pt_BR: Instalação gráfica fácil.

note: type: section
en: Manual Installation
pt_BR: Instalação manual

note: type: menuentry
en: Manual installation for wizards.
pt_BR: Instalação manual para magos.

note: type: section
en: After System Installation
pt_BR: Após a instalação do sistema

note: type: menuentry
en: When installation succeeded.
pt_BR: Quando a instalação conclui com sucesso.

note: type: node
en: Installing Guix in a VM
pt_BR: Instalando Guix em um VM

note: type: menuentry
en: Guix System playground.
pt_BR: Parque de diversões do Guix System.

note: type: section
en: Building the Installation Image
pt_BR: Compilando a imagem de instalação

note: type: menuentry
en: How this comes to be.
pt_BR: Como isso vem a ser.

note: type: node
en: Keyboard Layout and Networking and Partitioning
pt_BR: Disposição de teclado e rede e particionamento

note: type: menuentry
en: Initial setup.
pt_BR: Configuração inicial.

note: type: subsection
en: Proceeding with the Installation
pt_BR: Prosseguindo com a instalação

note: type: menuentry
en: Installing.
pt_BR: Instalando.

note: type: section
en: Features
pt_BR: Recursos

note: type: menuentry
en: How Guix will make your life brighter.
pt_BR: Como o Guix vai iluminar a sua vida.

note: type: node
en: Invoking guix package
pt_BR: Invocando guix package

note: type: menuentry
en: Package installation, removal, etc.
pt_BR: Instalação de pacote, remoção, etc.

note: type: section
en: Substitutes
pt_BR: Substitutos

note: type: menuentry
en: Downloading pre-built binaries.
pt_BR: Baixando binários pré-compilados.

note: type: section
en: Packages with Multiple Outputs
pt_BR: Pacotes com múltiplas saídas

note: type: menuentry
en: Single source package, multiple outputs.
pt_BR: Um único pacote de fontes, várias saídas.

note: type: node
en: Invoking guix gc
pt_BR: Invocando guix gc

note: type: menuentry
en: Running the garbage collector.
pt_BR: Executando o coletor de lixo.

note: type: node
en: Invoking guix pull
pt_BR: Invocando guix pull

note: type: menuentry
en: Fetching the latest Guix and distribution.
pt_BR: Obtendo o Guix mais recente e distribuição.

note: type: section
en: Inferiors
pt_BR: Inferiores

note: type: menuentry
en: Interacting with another revision of Guix.
pt_BR: Interagindo com outra revisão do Guix.

note: type: node
en: Invoking guix describe
pt_BR: Invocando guix describe

note: type: menuentry
en: Display information about your Guix revision.
pt_BR: Exibe informações sobre sua revisão do Guix.

note: type: node
en: Invoking guix archive
pt_BR: Invocando guix archive

note: type: menuentry
en: Exporting and importing store files.
pt_BR: Exportando e importando arquivos do armazém.

note: type: menuentry
en: One particular source of substitutes.
pt_BR: Uma fonte específica de substitutos.

note: type: subsection
en: Substitute Server Authorization
pt_BR: Autorização de servidor substituto

note: type: menuentry
en: How to enable or disable substitutes.
pt_BR: Como habilitar ou desabilitar substitutos.

note: type: subsection
en: Substitute Authentication
pt_BR: Autenticação de substituto

note: type: menuentry
en: How Guix verifies substitutes.
pt_BR: Como Guix verifica substitutos.

note: type: subsection
en: Proxy Settings
pt_BR: Configurações de proxy

note: type: menuentry
en: How to get substitutes via proxy.
pt_BR: Como obter substitutos via proxy.

note: type: subsection
en: Substitution Failure
pt_BR: Falha na substituição

note: type: menuentry
en: What happens when substitution fails.
pt_BR: O que acontece quando a substituição falha.

note: type: subsection
en: On Trusting Binaries
pt_BR: Confiança em binários

note: type: menuentry
en: How can you trust that binary blob?
pt_BR: Como você pode confiar naquele blob binário?

note: type: node
en: Invoking guix environment
pt_BR: Invocando guix environment

note: type: menuentry
en: Setting up development environments.
pt_BR: Configurando ambientes de desenvolvimento.

note: type: node
en: Invoking guix pack
pt_BR: Invocando guix pack

note: type: menuentry
en: Creating software bundles.
pt_BR: Criando pacotes de software.

note: type: section
en: Package Modules
pt_BR: Módulos de pacote

note: type: menuentry
en: Packages from the programmer's viewpoint.
pt_BR: Pacotes do ponto de vista do programador.

note: type: section
en: Defining Packages
pt_BR: Definindo pacotes

note: type: menuentry
en: Defining new packages.
pt_BR: Definindo novos pacotes.

note: type: section
en: Build Systems
pt_BR: Sistemas de compilação

note: type: menuentry
en: Specifying how packages are built.
pt_BR: Especificando como pacotes são compilados.

note: type: section
en: The Store
pt_BR: O armazém

note: type: menuentry
en: Manipulating the package store.
pt_BR: Manipulação do armazém de pacotes.

note: type: section
en: Derivations
pt_BR: Derivações

note: type: menuentry
en: Low-level interface to package derivations.
pt_BR: Interface de baixo nível para derivações de pacotes.

note: type: section
en: The Store Monad
pt_BR: A mônada do armazém

note: type: menuentry
en: Purely functional interface to the store.
pt_BR: Interface puramente funcional para o armazém.

note: type: section
en: G-Expressions
pt_BR: Expressões-G

note: type: menuentry
en: Manipulating build expressions.
pt_BR: Manipulação de expressões de compilação.

note: type: node
en: Invoking guix repl
pt_BR: Invocando guix repl

note: type: node
en: package Reference
pt_BR: Referência do package

note: type: menuentry
en: The package data type.
pt_BR: O tipo de dados package.

note: type: node
en: origin Reference
pt_BR: Referência do origin

note: type: menuentry
en: The origin data type.
pt_BR: O tipo de dados origin.

note: type: node
en: Invoking guix build
pt_BR: Invocando guix build

note: type: menuentry
en: Building packages from the command line.
pt_BR: Compilando pacotes a partir da linha de comando.

note: type: node
en: Invoking guix edit
pt_BR: Invocando guix edit

note: type: menuentry
en: Editing package definitions.
pt_BR: Editando definições de pacote.

note: type: node
en: Invoking guix download
pt_BR: Invocando guix download

note: type: menuentry
en: Downloading a file and printing its hash.
pt_BR: Baixando um arquivo e imprimindo seu hash.

note: type: node
en: Invoking guix hash
pt_BR: Invocando guix hash

note: type: menuentry
en: Computing the cryptographic hash of a file.
pt_BR: Computando a hash criptográfica de um arquivo.

note: type: node
en: Invoking guix import
pt_BR: Invocando guix import

note: type: menuentry
en: Importing package definitions.
pt_BR: Importando definições de pacote.

note: type: node
en: Invoking guix refresh
pt_BR: Invocando guix refresh

note: type: menuentry
en: Updating package definitions.
pt_BR: Atualizando definições de pacotes.

note: type: node
en: Invoking guix lint
pt_BR: Invocando guix lint

note: type: menuentry
en: Finding errors in package definitions.
pt_BR: Encontrando erros nas definições de pacote.

note: type: node
en: Invoking guix size
pt_BR: Invocando guix size

note: type: menuentry
en: Profiling disk usage.
pt_BR: Perfilando uso de disco.

note: type: node
en: Invoking guix graph
pt_BR: Invocando guix graph

note: type: menuentry
en: Visualizing the graph of packages.
pt_BR: Visualizando o grafo de pacotes.

note: type: node
en: Invoking guix publish
pt_BR: Invocando guix publish

note: type: menuentry
en: Sharing substitutes.
pt_BR: Compartilhando substitutos.

note: type: node
en: Invoking guix challenge
pt_BR: Invocando guix challenge

note: type: menuentry
en: Challenging substitute servers.
pt_BR: Desafiando servidores substitutos.

note: type: node
en: Invoking guix copy
pt_BR: Invocando guix copy

note: type: menuentry
en: Copying to and from a remote store.
pt_BR: Copiando para e de um armazém remoto.

note: type: node
en: Invoking guix container
pt_BR: Invocando guix container

note: type: menuentry
en: Process isolation.
pt_BR: Isolação de processo.

note: type: node
en: Invoking guix weather
pt_BR: Invocando guix weather

note: type: menuentry
en: Assessing substitute availability.
pt_BR: Acessando disponibilidade de substituto.

note: type: node
en: Invoking guix processes
pt_BR: Invocando guix processes

note: type: menuentry
en: Listing client processes.
pt_BR: Listando processos do cliente.

note: type: section
en: Invoking @command{guix build}
pt_BR: Invocando @command{guix build}

note: type: subsection
en: Common Build Options
pt_BR: Opções de compilação comum

note: type: menuentry
en: Build options for most commands.
pt_BR: Opções de compilação para a maioria dos comandos.

note: type: subsection
en: Package Transformation Options
pt_BR: Opções de transformação de pacote

note: type: menuentry
en: Creating variants of packages.
pt_BR: Criando variantes de pacotes.

note: type: subsection
en: Additional Build Options
pt_BR: Opções de compilação adicional

note: type: menuentry
en: Options specific to 'guix build'.
pt_BR: Opções específicas para "guix build".

note: type: subsection
en: Debugging Build Failures
pt_BR: Depurando falhas de compilação

note: type: menuentry
en: Real life packaging experience.
pt_BR: Experiência de empacotamento na vida real.

note: type: section
en: Using the Configuration System
pt_BR: Usando o sistema de configuração

note: type: menuentry
en: Customizing your GNU system.
pt_BR: Personalizando seu sistema GNU.

note: type: node
en: operating-system Reference
pt_BR: Referência do operating-system

note: type: menuentry
en: Detail of operating-system declarations.
pt_BR: Detalhe das declarações do operating-system.

note: type: section
en: File Systems
pt_BR: Sistemas de arquivos

note: type: menuentry
en: Configuring file system mounts.
pt_BR: Configurando montagens de sistema de arquivos.

note: type: section
en: Mapped Devices
pt_BR: Dispositivos mapeados

note: type: menuentry
en: Block device extra processing.
pt_BR: Processamento extra de dispositivo de bloco.

note: type: section
en: User Accounts
pt_BR: Contas de usuários

note: type: menuentry
en: Specifying user accounts.
pt_BR: Especificando contas de usuários.

note: type: section
en: Keyboard Layout
pt_BR: Disposição do teclado

note: type: menuentry
en: How the system interprets key strokes.
pt_BR: Como o sistema interpreta pressionamento de teclas.

note: type: menuentry
en: Language and cultural convention settings.
pt_BR: Configurações de idioma e de convenção cultural.

note: type: node
en: Services
pt_BR: Serviços

note: type: menuentry
en: Specifying system services.
pt_BR: Especificando serviços de sistema.

note: type: section
en: Setuid Programs
pt_BR: Programas setuid

note: type: section
en: X.509 Certificates
pt_BR: Certificados X.509

note: type: menuentry
en: Authenticating HTTPS servers.
pt_BR: Autenticando servidores HTTPS.

note: type: menuentry
en: Configuring libc's name service switch.
pt_BR: Configurando name service switch do libc.

note: type: section
en: Initial RAM Disk
pt_BR: Disco de RAM inicial

note: type: menuentry
en: Linux-Libre bootstrapping.
pt_BR: Inicialização do Linux-Libre.

note: type: section
en: Bootloader Configuration
pt_BR: Configuração do carregador de inicialização

note: type: menuentry
en: Configuring the boot loader.
pt_BR: Configurando o "bootloader".

note: type: node
en: Invoking guix system
pt_BR: Invocando guix system

note: type: menuentry
en: Instantiating a system configuration.
pt_BR: Inicializando uma configuração de sistema.

note: type: node
en: Running Guix in a VM
pt_BR: Executando Guix em uma VM

note: type: menuentry
en: How to run Guix System in a virtual machine.
pt_BR: Como executar Guix System em uma máquina virtual.

note: type: section
en: Defining Services
pt_BR: Definindo serviços

note: type: menuentry
en: Adding new service definitions.
pt_BR: Adicionando novas definições de serviço.

note: type: subsection
en: Base Services
pt_BR: Serviços base

note: type: menuentry
en: Essential system services.
pt_BR: Serviços essenciais do sistema.

note: type: subsection
en: Scheduled Job Execution
pt_BR: Execução de trabalho agendado

note: type: menuentry
en: The mcron service.
pt_BR: O serviço mcron.

note: type: subsection
en: Log Rotation
pt_BR: Rotação de log

note: type: menuentry
en: The rottlog service.
pt_BR: O serviço rottlog.

note: type: menuentry
en: Setting up network interfaces.
pt_BR: Configurando interfaces de rede.

note: type: subsection
en: Networking Services
pt_BR: Serviços de Rede

note: type: menuentry
en: Graphical display.
pt_BR: Exibição gráfica.

note: type: subsection
en: Printing Services
pt_BR: Serviços de impressão

note: type: menuentry
en: Local and remote printer support.
pt_BR: Suporte a impressora local e remota.

note: type: subsection
en: Desktop Services
pt_BR: Serviços de desktop

note: type: menuentry
en: D-Bus and desktop services.
pt_BR: Serviços de D-Bus e desktop.

note: type: subsection
en: Sound Services
pt_BR: Serviços de som

note: type: menuentry
en: ALSA and Pulseaudio services.
pt_BR: Serviços ALSA e Pulseaudio.

note: type: subsection
en: Database Services
pt_BR: Serviços de bancos de dados

note: type: menuentry
en: SQL databases, key-value stores, etc.
pt_BR: Banco de dados SQL, armazenamentos de valor chave, etc.

note: type: subsection
en: Mail Services
pt_BR: Serviços de correio

note: type: menuentry
en: IMAP, POP3, SMTP, and all that.
pt_BR: IMAP, POP3, SMTP e tudo isso.

note: type: subsection
en: Messaging Services
pt_BR: Serviços de mensageria

note: type: menuentry
en: Messaging services.
pt_BR: Serviços de mensageria.

note: type: subsection
en: Telephony Services
pt_BR: Serviços de telefonia

note: type: menuentry
en: Telephony services.
pt_BR: Serviços de telefonia.

note: type: subsection
en: Monitoring Services
pt_BR: Serviços de monitoramento

note: type: menuentry
en: Monitoring services.
pt_BR: Serviços de monitoramento.

note: type: subsection
en: Kerberos Services
pt_BR: Serviços Kerberos

note: type: menuentry
en: Kerberos services.
pt_BR: Serviços Kerberos.

note: type: subsection
en: Web Services
pt_BR: Serviços Web

note: type: menuentry
en: Web servers.
pt_BR: Servidores Web.

note: type: subsection
en: Certificate Services
pt_BR: Serviços de certificado

note: type: menuentry
en: TLS certificates via Let's Encrypt.
pt_BR: Certificados TLS via Let's Encrypt.

note: type: subsection
en: DNS Services
pt_BR: Serviços DNS

note: type: menuentry
en: DNS daemons.
pt_BR: Deamons DNS.

note: type: subsection
en: VPN Services
pt_BR: Serviços VPN

note: type: menuentry
en: VPN daemons.
pt_BR: Deamons VPN.

note: type: node
en: Network File System
pt_BR: Sistema de arquivos de rede

note: type: menuentry
en: NFS related services.
pt_BR: Serviços relacionados a NFS.

note: type: subsection
en: Continuous Integration
pt_BR: Integração contínua

note: type: subsection
en: Power Management Services
pt_BR: Serviços de gerenciamento de energia

note: type: menuentry
en: Extending battery life.
pt_BR: Estendendo a vida da bateria.

note: type: subsection
en: Audio Services
pt_BR: Serviços de áudio

note: type: menuentry
en: The MPD.
pt_BR: O MPD.

note: type: subsection
en: Virtualization Services
pt_BR: Serviços de virtualização

note: type: menuentry
en: Virtualization services.
pt_BR: Serviços de virtualização.

note: type: subsection
en: Version Control Services
pt_BR: Serviços de controlando versão

note: type: menuentry
en: Providing remote access to Git repositories.
pt_BR: Fornecendo acesso remoto a repositórios Git.

note: type: subsection
en: Game Services
pt_BR: Serviços de jogos

note: type: menuentry
en: Game servers.
pt_BR: Servidores de jogos.

note: type: subsection
en: Miscellaneous Services
pt_BR: Serviços diversos

note: type: menuentry
en: Other services.
pt_BR: Outros serviços.

note: type: subsection
en: Service Composition
pt_BR: Composição de serviço

note: type: menuentry
en: The model for composing services.
pt_BR: O modelo para serviços de composição.

note: type: subsection
en: Service Types and Services
pt_BR: Tipos de Service e Serviços

note: type: menuentry
en: Types and services.
pt_BR: Tipos e serviços.

note: type: subsection
en: Service Reference
pt_BR: Referência de Service

note: type: menuentry
en: API reference.
pt_BR: Referência de API.

note: type: subsection
en: Shepherd Services
pt_BR: Serviços de Shepherd

note: type: menuentry
en: A particular type of service.
pt_BR: Um tipo em particular de serviço.

note: type: cindex
en: purpose
pt_BR: propósito

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: cindex
en: GuixSD, now Guix System
pt_BR: GuixSD, agora Guix System

note: type: cindex
en: Guix System Distribution, now Guix System
pt_BR: Guix System Distribution, agora Guix System

note: type: Plain text
en: 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}.
pt_BR: Você pode instalar o GNU@tie{}Guix sobre um sistema GNU/Linux existente, onde ele complementa as ferramentas disponíveis sem interferência (@pxref{Instalação}) 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{Distribuição GNU}.

note: type: cindex
en: user interfaces
pt_BR: interfaces de usuário

note: type: Plain text
en: 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}).
pt_BR: O @dfn{build daemon} é responsável por compilar pacotes em nome dos usuários (@pxref{Configurando o daemon}) e por baixar binários pré-compilados de fontes autorizados (@pxref{Substitutos}).

note: type: cindex
en: extensibility of the distribution
pt_BR: extensibilidade da distribuição

note: type: cindex
en: customization, of packages
pt_BR: personalização, de pacotes

note: type: Plain text
en: 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}).
pt_BR: 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{Definindo pacotes}) e disponibilizá-los como módulos de pacotes independentes (@pxref{Módulos de pacote}). Também é @emph{personalizável}: os usuários podem @emph{derivar} definições de pacotes especializados das existentes, incluindo da linha de comando (@pxref{Opções de transformação de pacote}).

note: type: cindex
en: functional package management
pt_BR: gerenciamento de pacotes funcional

note: type: cindex
en: isolation
pt_BR: isolação

note: type: Plain text
en: 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.
pt_BR: Nos bastidores, a Guix implementa a disciplina @dfn{gerenciamento de pacotes funcional} pioneira da Nix (@pxref{Agradecimentos}). 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.

note: type: cindex
en: store
pt_BR: armazém

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: 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}).
pt_BR: 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{Recursos}).

note: type: Plain text
en: 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.
pt_BR: 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{Instalação do sistema}), mas também é possível instalar o Guix como um gerenciador de pacotes em cima de um sistema GNU/Linux instalado (@pxref{Instalação}). Quando precisamos distinguir entre os dois, nos referimos à distribuição independente como Guix@tie{}System.

note: type: Plain text
en: 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}):
pt_BR: 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{Invocando guix package}):

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: Packages are currently available on the following platforms:
pt_BR: Os pacotes estão atualmente disponíveis nas seguintes plataformas:

note: type: table
en: ARMv7-A architecture with hard float, Thumb-2 and NEON, using the EABI hard-float application binary interface (ABI), and Linux-Libre kernel.
pt_BR: 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.

note: type: Plain text
en: 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.
pt_BR: 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{Configuração do sistema}). 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.

note: type: Plain text
en: For information on porting to other architectures or kernels, @pxref{Porting}.
pt_BR: Para obter informações sobre como portar para outras arquiteturas ou kernels, @pxref{Portando}.

note: type: Plain text
en: Building this distribution is a cooperative effort, and you are invited to join! @xref{Contributing}, for information about how you can help.
pt_BR: A construção desta distribuição é um esforço cooperativo e você está convidado a participar! @xref{Contribuindo}, para obter informações sobre como você pode ajudar.

note: type: cindex
en: installing Guix
pt_BR: instalando Guix

note: type: quotation
en: We recommend the use of this @uref{https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh, shell installer script} to install Guix on top of a running GNU/Linux system, thereafter called a @dfn{foreign distro}.@footnote{This section is concerned with the installation of the package manager, which can be done on top of a running GNU/Linux system.  If, instead, you want to install the complete GNU operating system, @pxref{System Installation}.} The script automates the download, installation, and initial configuration of Guix.  It should be run as the root user.
pt_BR: Recomendamos o uso deste @uref{https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh, script de instalação do shell} para instalar o Guix sobre o sistema GNU/Linux que você esteja usando, posteriormente denominado @dfn{distro alheia}.@footnote{Esta seção trata da instalação do gerenciador de pacotes, que pode ser feita sobre um sistema GNU/Linux atualmente em uso. Se, em vez disso, você deseja instalar o sistema operacional GNU completo, @pxref{Instalação do sistema}.} O script automatiza o download, a instalação e a configuração inicial do Guix. Ele deve ser executado como usuário root.

note: type: cindex
en: foreign distro
pt_BR: distro alheia

note: type: cindex
en: directories related to foreign distro
pt_BR: diretórios relacionados à distro alheia

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: Once installed, Guix can be updated by running @command{guix pull} (@pxref{Invoking guix pull}).
pt_BR: Uma vez instalado, o Guix pode ser atualizado executando @command{guix pull} (@pxref{Invocando guix pull}).

note: type: Plain text
en: If you prefer to perform the installation steps manually or want to tweak them, you may find the following subsections useful.  They describe the software requirements of Guix, as well as how to install it manually and get ready to use it.
pt_BR: Se você preferir executar as etapas de instalação manualmente ou desejar ajustá-las, poderá achar úteis as seguintes subseções. Eles descrevem os requisitos de software do Guix, bem como instalá-lo manualmente e se preparar para usá-lo.

note: type: cindex
en: installing Guix from binaries
pt_BR: instalando Guix de binários

note: type: cindex
en: installer script
pt_BR: script de instalação

note: type: Plain text
en: This section describes how to install Guix on an arbitrary system from a self-contained tarball providing binaries for Guix and for all its dependencies.  This is often quicker than installing from source, which is described in the next sections.  The only requirement is to have GNU@tie{}tar and Xz.
pt_BR: Esta seção descreve como instalar o Guix em um sistema arbitrário a partir de um tarball independente que fornece binários para o Guix e para todas as suas dependências. Isso geralmente é mais rápido do que instalar do código-fonte, o que é descrito nas próximas seções. O único requisito é ter o GNU@tie{}tar e Xz.

note: type: Plain text
en: Installing goes along these lines:
pt_BR: A instalação segue as seguintes linhas:

note: type: cindex
en: downloading Guix binary
pt_BR: baixando binário do Guix

note: type: enumerate
en: Make sure to download the associated @file{.sig} file and to verify the authenticity of the tarball against it, along these lines:
pt_BR: Certifique-se de baixar o arquivo @file{.sig} associado e verificar a autenticidade do tarball, seguindo estas linhas:

note: type: Plain text
en: If that command fails because you do not have the required public key, then run this command to import it:
pt_BR: Se esse comando falhar porque você não possui a chave pública requerida, execute este comando para importá-lo:

note: type: Plain text
en: and rerun the @code{gpg --verify} command.
pt_BR: e execute novamente o comando @code{gpg --verify}.

note: type: enumerate
en: Now, you need to become the @code{root} user.  Depending on your distribution, you may have to run @code{su -} or @code{sudo -i}.  As @code{root}, run:
pt_BR: Agora, você precisa se tornar o usuário @code{root}. Dependendo de sua distribuição, você pode ter que executar @code{su -} ou @code{sudo -i}. Como @code{root}, execute:

note: type: enumerate
en: Do @emph{not} unpack the tarball on a working Guix system since that would overwrite its own essential files.
pt_BR: @emph{Não} descompacte o tarball em um sistema Guix funcional, pois isso substituiria seus próprios arquivos essenciais.

note: type: enumerate
en: Make the profile available under @file{~root/.config/guix/current}, which is where @command{guix pull} will install updates (@pxref{Invoking guix pull}):
pt_BR: Torne o perfil disponível sob @file{~root/.config/guix/current}, que é onde @command{guix pull} vai instalar atualizações (@pxref{Invoking guix pull}):

note: type: enumerate
en: Create the group and user accounts for build users as explained below (@pxref{Build Environment Setup}).
pt_BR: Crie o grupo e contas de usuário para compilar usuários conforme explicado abaixo (@pxref{Configuração do ambiente de compilação}).

note: type: enumerate
en: Run the daemon, and set it to automatically start on boot.
pt_BR: Execute o daemon e configure-o para iniciar automaticamente na inicialização do sistema.

note: type: enumerate
en: If your host distro uses the systemd init system, this can be achieved with these commands:
pt_BR: Se sua distro hospedeira usa o sistema init systemd, isso pode ser obtido com estes comandos:

note: type: itemize
en: If your host distro uses the Upstart init system:
pt_BR: Se sua distro hospedeira usa o sistema init Upstart:

note: type: enumerate
en: Otherwise, you can still start the daemon manually with:
pt_BR: Caso contrário, você ainda pode iniciar o daemon manualmente com:

note: type: enumerate
en: Make the @command{guix} command available to other users on the machine, for instance with:
pt_BR: Disponibilize o comando @command{guix} para outros usuários na máquina, por exemplo, com:

note: type: enumerate
en: It is also a good idea to make the Info version of this manual available there:
pt_BR: Também é uma boa ideia disponibilizar a versão Info deste manual:

note: type: cindex
en: substitutes, authorization thereof
pt_BR: substitutos, autenticação dela

note: type: enumerate
en: Each user may need to perform a few additional steps to make their Guix environment ready for use, @pxref{Application Setup}.
pt_BR: Cada usuário pode precisar executar algumas etapas adicionais para tornar seu ambiente Guix pronto para uso, @pxref{Configuração de aplicativo}.

note: type: Plain text
en: Voilà, the installation is complete!
pt_BR: Voilà, a instalação está completa!

note: type: Plain text
en: You can confirm that Guix is working by installing a sample package into the root profile:
pt_BR: Você pode confirmar que o Guix está funcionando instalando um pacote de amostra no perfil raiz:

note: type: Plain text
en: The binary installation tarball can be (re)produced and verified simply by running the following command in the Guix source tree:
pt_BR: 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:

note: type: Plain text
en: ...@: which, in turn, runs:
pt_BR: ...@: que, por sua vez, executa:

note: type: Plain text
en: @xref{Invoking guix pack}, for more info on this handy tool.
pt_BR: @xref{Invocando guix pack}, para mais informações sobre essa ferramenta útil.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: cindex
en: official website
pt_BR: site oficial

note: type: Plain text
en: GNU Guix is available for download from its website at @url{https://www.gnu.org/software/guix/}.
pt_BR: O GNU Guix está disponível para download em seu site em @url{http://www.gnu.org/software/guix/}.

note: type: Plain text
en: GNU Guix depends on the following packages:
pt_BR: GNU Guix depende dos seguintes pacotes:

note: type: item
en: @url{https://notabug.org/cwebber/guile-gcrypt, Guile-Gcrypt}, version
pt_BR: @url{https://notabug.org/cwebber/guile-gcrypt, Guile-Gcrypt}, versão

note: type: itemize
en: 0.1.0 or later;
pt_BR: 0.1.0 ou posterior;

note: type: itemize
en: @uref{https://notabug.org/guile-sqlite3/guile-sqlite3, Guile-SQLite3}, version 0.1.0 or later;
pt_BR: @uref{https://notabug.org/guile-sqlite3/guile-sqlite3, Guile-SQLite3}, versão 0.1.0 ou posterior;

note: type: Plain text
en: The following dependencies are optional:
pt_BR: As seguintes dependências são opcionais:

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

note: type: item
en: @url{https://gcc.gnu.org, GCC's g++}, with support for the
pt_BR: @url{https://gcc.gnu.org, GCC's g++}, com suporte ao

note: type: itemize
en: C++11 standard.
pt_BR: padrão C++11.

note: type: cindex
en: state directory
pt_BR: diretório de estado

note: type: cindex
en: test suite
pt_BR: suíte/conjunto de testes

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: 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.
pt_BR: 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.

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

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: 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.
pt_BR: 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{Requisitos}) em sua mensagem.

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: or, again, by defining @code{TESTS} to select a subset of tests to run:
pt_BR: ou, novamente, definindo @code{TESTS} para selecionar um subconjunto de testes a serem executados:

note: type: Plain text
en: 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.
pt_BR: 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{Substitutos}). Alguns deles exigem muito espaço de armazenamento para armazenar imagens de VM.

note: type: Plain text
en: Again in case of test failures, please send @email{bug-guix@@gnu.org} all the details.
pt_BR: Novamente, em caso de falhas nos testes, por favor envie @email{bug-guix@@gnu.org} todos os detalhes.

note: type: Plain text
en: Operations such as building a package or running the garbage collector are all performed by a specialized process, the @dfn{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.
pt_BR: Operações como compilar um pacote ou executar o coletor de lixo são todas executadas por um processo especializado, o @dfn{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.

note: type: Plain text
en: The following sections explain how to prepare the build daemon's environment.  See also @ref{Substitutes}, for information on how to allow the daemon to download pre-built binaries.
pt_BR: As seções a seguir explicam como preparar o ambiente do daemon de compilação. Veja também @ref{Substitutos}, para informações sobre como permitir que o daemon baixe binários pré-compilados.

note: type: cindex
en: build environment
pt_BR: ambiente de compilação

note: type: Plain text
en: In a standard multi-user setup, Guix and its daemon---the @command{guix-daemon} program---are installed by the system administrator; @file{/gnu/store} is owned by @code{root} and @command{guix-daemon} runs as @code{root}.  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.
pt_BR: 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; @file{/gnu/store} é de propriedade de @code{root} e @command{guix-daemon} é executado como @code{root}. 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.

note: type: cindex
en: build users
pt_BR: usuários de compilação

note: type: Plain text
en: 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.  These build users need not have a shell and a home directory: they will just be used when the daemon drops @code{root} privileges in build processes.  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}).
pt_BR: 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. Esses usuários de compilação não precisam ter um shell e um diretório inicial: eles serão usados apenas quando o daemon der um privilégio @code{root} nos processos de compilação. 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{Introdução}).

note: type: Plain text
en: On a GNU/Linux system, a build user pool may be created like this (using Bash syntax and the @code{shadow} commands):
pt_BR: 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}):

note: type: Plain text
en: 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}).
pt_BR: 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{Invocando 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{Invocando guix system}).

note: type: Plain text
en: This way, the daemon starts build processes in a chroot, under one of the @code{guixbuilder} users.  On GNU/Linux, by default, the chroot environment contains nothing but:
pt_BR: Dessa forma, o daemon inicia os processos de compilação em um chroot, sob um dos usuários @code{guixbuilder}. No GNU/Linux, por padrão, o ambiente chroot contém nada além de:

note: type: itemize
en: 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.};
pt_BR: 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.};

note: type: itemize
en: the @code{/proc} directory; it only shows the processes of the container since a separate PID name space is used;
pt_BR: o diretório @code{/proc}; mostra apenas os processos do contêiner desde que um espaço de nome PID separado é usado;

note: type: itemize
en: @file{/etc/passwd} with an entry for the current user and an entry for user @file{nobody};
pt_BR: @file{/etc/passwd} com uma entrada para o usuário atual e uma entrada para o usuário @file{nobody};

note: type: itemize
en: @file{/etc/group} with an entry for the user's group;
pt_BR: @file{/etc/group} com uma entrada para o grupo de usuários;

note: type: itemize
en: @file{/etc/hosts} with an entry that maps @code{localhost} to @code{127.0.0.1};
pt_BR: @file{/etc/hosts} com uma entrada que mapeia @code{localhost} para @code{127.0.0.1};

note: type: itemize
en: a writable @file{/tmp} directory.
pt_BR: um diretório @file{/tmp} com permissão de escrita.

note: type: subsection
en: Using the Offload Facility
pt_BR: Usando o recurso de descarregamento

note: type: cindex
en: offloading
pt_BR: descarregamento

note: type: cindex
en: build hook
pt_BR: hook de compilação

note: type: Plain text
en: The @file{/etc/guix/machines.scm} file typically looks like this:
pt_BR: O arquivo @file{/etc/guix/machines.scm} geralmente se parece com isso:

note: type: Plain text
en: 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.
pt_BR: De fato, esse arquivo é -- não surpreendentemente! -- um arquivo de esquema 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.

note: type: deftp
en: {Data Type} build-machine
pt_BR: build-machine {Data Type}

note: type: deftp
en: This data type represents build machines to which the daemon may offload builds.  The important fields are:
pt_BR: Esse tipo de dados representa máquinas de compilação nas quais o daemon pode descarregar compilações. Os campos importantes são:

note: type: table
en: The host name of the remote machine.
pt_BR: O nome de host da máquina remota.

note: type: table
en: The user account to use when connecting to the remote machine over SSH.  Note that the SSH key pair must @emph{not} be passphrase-protected, to allow non-interactive logins.
pt_BR: A conta de usuário a ser usada ao conectar-se à máquina remota por SSH. Observe que o par de chaves SSH deve @emph{não} protegido por senha, para permitir logins não interativos.

note: type: table
en: 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:
pt_BR: 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:

note: type: table
en: 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}.
pt_BR: 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}.

note: type: table
en: If the machine is running the SSH daemon of GNU@tie{}lsh, @command{lshd}, the host key is in @file{/etc/lsh/host-key.pub} or a similar file.  It can be converted to the OpenSSH format using @command{lsh-export-key} (@pxref{Converting keys,,, lsh, LSH Manual}):
pt_BR: Se a máquina estiver executando o daemon SSH do GNU@tie{}lsh, @command{lshd}, a chave do host estará em @file{/etc/lsh/host-key.pub} ou em um arquivo semelhante. Ele pode ser convertido para o formato OpenSSH usando o @command{lsh-export-key} (@pxref{Converting keys,,, lsh, LSH Manual}):

note: type: deftp
en: A number of optional fields may be specified:
pt_BR: Vários campos opcionais podem ser especificados:

note: type: item
en: @code{port} (default: @code{22})
pt_BR: @code{port} (padrão: @code{22})

note: type: table
en: Port number of SSH server on the machine.
pt_BR: O número da porta para o servidor SSH na máquina.

note: type: item
en: @code{private-key} (default: @file{~root/.ssh/id_rsa})
pt_BR: @code{private-key} (padrão: @file{~root/.ssh/id_rsa})

note: type: table
en: The SSH private key file to use when connecting to the machine, in OpenSSH format.  This key must not be protected with a passphrase.
pt_BR: 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.

note: type: table
en: Note that the default value is the private key @emph{of the root account}.  Make sure it exists if you use the default.
pt_BR: Observe que o valor padrão é a chave privada @emph{da usuário root}. Verifique se ele existe se você usar o padrão.

note: type: item
en: @code{compression} (default: @code{"zlib@@openssh.com,zlib"})
pt_BR: @code{compression} (padrão: @code{"zlib@@openssh.com,zlib"})

note: type: itemx
en: @code{compression-level} (default: @code{3})
pt_BR: @code{compression-level} (padrão: @code{3})

note: type: table
en: The SSH-level compression methods and compression level requested.
pt_BR: Os métodos de compactação no nível SSH e o nível de compactação solicitado.

note: type: table
en: Note that offloading relies on SSH compression to reduce bandwidth usage when transferring files to and from build machines.
pt_BR: 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.

note: type: item
en: @code{daemon-socket} (default: @code{"/var/guix/daemon-socket/socket"})
pt_BR: @code{daemon-socket} (padrão: @code{"/var/guix/daemon-socket/socket"})

note: type: table
en: File name of the Unix-domain socket @command{guix-daemon} is listening to on that machine.
pt_BR: O nome do arquivo do soquete do domínio Unix @command{guix-daemon} está escutando nessa máquina.

note: type: item
en: @code{parallel-builds} (default: @code{1})
pt_BR: @code{parallel-builds} (padrão: @code{1})

note: type: table
en: The number of builds that may run in parallel on the machine.
pt_BR: O número de compilações que podem ser executadas paralelamente na máquina.

note: type: item
en: @code{speed} (default: @code{1.0})
pt_BR: @code{speed} (padrão: @code{1.0})

note: type: table
en: A ``relative speed factor''.  The offload scheduler will tend to prefer machines with a higher speed factor.
pt_BR: Um ``fator de velocidade relativo''. O agendador de descarregamento tenderá a preferir máquinas com um fator de velocidade mais alto.

note: type: item
en: @code{features} (default: @code{'()})
pt_BR: @code{features} (padrão: @code{'()})

note: type: table
en: 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.
pt_BR: 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.

note: type: Plain text
en: The @command{guix} command must be in the search path on the build machines.  You can check whether this is the case by running:
pt_BR: O comando @command{guix} deve estar no caminho de pesquisa nas máquinas de compilação. Você pode verificar se este é o caso executando:

note: type: Plain text
en: 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}):
pt_BR: 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{Invocando guix archive}):

note: type: Plain text
en: Each build machine must authorize the key of the master machine so that it accepts store items it receives from the master:
pt_BR: 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:

note: type: Plain text
en: Likewise, the master machine must authorize the key of each build machine.
pt_BR: Da mesma forma, a máquina principal deve autorizar a chave de cada máquina de compilação.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: Plain text
en: To test whether your setup is operational, run this command on the master node:
pt_BR: Para testar se sua configuração está operacional, execute este comando no nó principal:

note: type: Plain text
en: If you want to test a different machine file, just specify it on the command line:
pt_BR: Se você quiser testar um arquivo de máquina diferente, basta especificá-lo na linha de comando:

note: type: Plain text
en: Last, you can test the subset of the machines whose name matches a regular expression like this:
pt_BR: Por fim, você pode testar o subconjunto das máquinas cujo nome corresponde a uma expressão regular como esta:

note: type: Plain text
en: To display the current load of all build hosts, run this command on the main node:
pt_BR: Para exibir o carregamento atual de todos os hosts de compilação, execute este comando no nó principal:

note: type: cindex
en: SELinux, daemon policy
pt_BR: SELinux, política de daemons

note: type: cindex
en: mandatory access control, SELinux
pt_BR: controle de acesso obrigatório, SELinux

note: type: cindex
en: security, guix-daemon
pt_BR: segurança, guix-daemon

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: subsubsection
en: Installing the SELinux policy
pt_BR: Instalando a política do SELinux

note: type: cindex
en: SELinux, policy installation
pt_BR: SELinux, instalação de política

note: type: Plain text
en: To install the policy run this command as root:
pt_BR: Para instalar a política, execute esse comando como root:

note: type: Plain text
en: Then relabel the file system with @code{restorecon} or by a different mechanism provided by your system.
pt_BR: Em seguida, altere o rótulo do sistema de arquivos com @code{restorecon} ou por um mecanismo diferente fornecido pelo seu sistema.

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: Monitor the SELinux log files as you run a command like @code{guix build hello} to convince yourself that SELinux permits all necessary operations.
pt_BR: 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.

note: type: cindex
en: SELinux, limitations
pt_BR: SELinux, limitações

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: enumerate
en: @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 $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.
pt_BR: @code{guix gc} não pode acessar links arbitrários para perfis. Por design, o rótulo do arquivo do destino de um link simbólico é independente do rótulo do arquivo do próprio link. Embora todos os perfis em $localstatedir estejam rotulados, os links para esses perfis herdam o rótulo do diretório em que estão. Para os links no diretório inicial do usuário, será @code{user_home_t}. Mas, para links do diretório inicial do usuário raiz, 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 esses links.

note: type: enumerate
en: 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.
pt_BR: 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.

note: type: enumerate
en: 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.
pt_BR: 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.

note: type: enumerate
en: 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.
pt_BR: 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.

note: type: section
en: Invoking @command{guix-daemon}
pt_BR: Invocando @command{guix-daemon}

note: type: Plain text
en: 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:
pt_BR: 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:

note: type: Plain text
en: For details on how to set it up, @pxref{Setting Up the Daemon}.
pt_BR: Para detalhes sobre como configurá-lo, @pxref{Configurando o daemon}.

note: type: cindex
en: container, build environment
pt_BR: contêiner, ambiente de compilação

note: type: cindex
en: reproducible builds
pt_BR: compilações reproduzíveis

note: type: Plain text
en: The following command-line options are supported:
pt_BR: As seguintes opções de linha de comando são suportadas:

note: type: item
en: --build-users-group=@var{group}
pt_BR: --build-users-group=@var{grupo}

note: type: table
en: Take users from @var{group} to run build processes (@pxref{Setting Up the Daemon, build users}).
pt_BR: Obtém os usuários do @var{grupo} para executar os processos de compilação (@pxref{Configurando o daemon, usuários de compilação}).

note: type: cindex
en: substitutes
pt_BR: substitutos

note: type: table
en: Do not use substitutes for build products.  That is, always build things locally instead of allowing downloads of pre-built binaries (@pxref{Substitutes}).
pt_BR: Não use substitutos para compilar produtos. Ou seja, sempre crie coisas localmente, em vez de permitir downloads de binários pré-compilados (@pxref{Substitutos}).

note: type: table
en: This means that substitutes may be downloaded from @var{urls}, as long as they are signed by a trusted signature (@pxref{Substitutes}).
pt_BR: Isso significa que os substitutos podem ser baixados de @var{urls}, desde que assinados por uma assinatura confiável (@pxref{Substitutos}).

note: type: table
en: Cache build failures.  By default, only successful builds are cached.
pt_BR: Armazena em cache as compilações que falharam. Por padrão, apenas compilações bem-sucedidas são armazenadas em cache.

note: type: table
en: 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}.
pt_BR: 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{Invocando guix gc}.

note: type: table
en: Use @var{n} CPU cores to build each derivation; @code{0} means as many as available.
pt_BR: Usa @var{n} núcleos de CPU para compilar cada derivação; @code{0} significa todos disponíveis.

note: type: table
en: 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.
pt_BR: 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{Configuração de descarregamento de daemon}) ou simplesmente falhará.

note: type: item
en: --max-silent-time=@var{seconds}
pt_BR: --max-silent-time=@var{segundos}

note: type: table
en: When the build or substitution process remains silent for more than @var{seconds}, terminate it and report a build failure.
pt_BR: 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.

note: type: table
en: The default value is @code{0}, which disables the timeout.
pt_BR: O valor padrão é @code{0}, que desativa o tempo limite.

note: type: item
en: --timeout=@var{seconds}
pt_BR: --timeout=@var{segundos}

note: type: table
en: Likewise, when the build or substitution process lasts for more than @var{seconds}, terminate it and report a build failure.
pt_BR: 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.

note: type: table
en: 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}).
pt_BR: 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{Invocando guix build}).

note: type: table
en: 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.
pt_BR: 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.

note: type: table
en: Produce debugging output.
pt_BR: Produz uma saída de depuração.

note: type: table
en: Add @var{dir} to the build chroot.
pt_BR: adiciona @var{dir} ao chroot de compilação.

note: type: table
en: 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.
pt_BR: 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.

note: type: table
en: Disable chroot builds.
pt_BR: Desabilita compilações em chroot.

note: type: table
en: Using this option is not recommended since, again, it would allow build processes to gain access to undeclared dependencies.  It is necessary, though, when @command{guix-daemon} is running under an unprivileged user account.
pt_BR: O uso dessa opção não é recomendado, pois, novamente, isso permitiria que os processos de compilação obtivessem acesso a dependências não declaradas. Porém, é necessário quando o @command{guix-daemon} está sendo executado em uma conta de usuário sem privilégios.

note: type: item
en: --log-compression=@var{type}
pt_BR: --log-compression=@var{tipo}

note: type: table
en: Compress build logs according to @var{type}, one of @code{gzip}, @code{bzip2}, or @code{none}.
pt_BR: Compacta logs de compilação de aconrdo com @var{tipo}, que pode ser um entre @code{gzip}, @code{bzip2} e @code{none}.

note: type: cindex
en: deduplication
pt_BR: deduplicação

note: type: table
en: Disable automatic file ``deduplication'' in the store.
pt_BR: Desabilita ``deduplicação'' automática de arquivos no armazém.

note: type: table
en: 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.
pt_BR: 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.

note: type: table
en: Tell whether the garbage collector (GC) must keep outputs of live derivations.
pt_BR: Diz se o coletor de lixo (GC) deve manter as saídas de derivações vivas.

note: type: cindex
en: GC roots
pt_BR: raízes de GC

note: type: cindex
en: garbage collector roots
pt_BR: raízes de coletor de lixo

note: type: table
en: Tell whether the garbage collector (GC) must keep derivations corresponding to live outputs.
pt_BR: Diz se o coletor de lixo (GC) deve manter as derivações correspondentes às saídas vivas.

note: type: Plain text
en: 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.
pt_BR: 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.

note: type: cindex
en: locales, when not on Guix System
pt_BR: locales, quando não está no Guix System

note: type: Plain text
en: 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.
pt_BR: 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ê.

note: type: Plain text
en: 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.
pt_BR: 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{Certificados X.509}, para informações detalhadas.

note: type: cindex
en: installing Guix System
pt_BR: instalando o Guix System

note: type: cindex
en: Guix System, installation
pt_BR: Guix System, instalação

note: type: cindex
en: hardware support on Guix System
pt_BR: suporte a hardware no Guix System

note: type: cindex
en: keyboard layout
pt_BR: disposição do teclado

note: type: subsubsection
en: Networking
pt_BR: Rede

note: type: item
en: Wired connection
pt_BR: Conexão cabeada

note: type: cindex
en: wireless
pt_BR: sem fio

note: type: Plain text
en: 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!
pt_BR: 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{Após a instalação do sistema}, para o que vem a seguir!

note: type: cindex
en: virtual machine, Guix System installation
pt_BR: máquina virtual, instalação do Guix System

note: type: section
en: Invoking @command{guix package}
pt_BR: Invocando @command{guix package}

note: type: example
en: guix package @var{options}
pt_BR: guix package @var{opções}

note: type: itemx
en: -f @var{file}
pt_BR: -f @var{arquivo}

note: type: itemx
en: -r @var{package} @dots{}
pt_BR: -r @var{pacote} @dots{}

note: type: item
en: --manifest=@var{file}
pt_BR: --manifest=@var{arquivo}

note: type: itemx
en: -m @var{file}
pt_BR: -m @var{arquivo}

note: type: cindex
en: profile declaration
pt_BR: declaração de perfil

note: type: cindex
en: profile manifest
pt_BR: manifsto de perfil

note: type: lisp
en: (packages->manifest
     (list emacs
           guile-2.0
           ;; Use a specific package output.
           (list guile-2.0 "debug")))
pt_BR: (packages->manifest
     (list emacs
           guile-2.0
           ;; Usa uma saída de pacote específica.
           (list guile-2.0 "debug")))

note: type: cindex
en: undoing transactions
pt_BR: desfazendo transações

note: type: cindex
en: transactions, undoing
pt_BR: transações, desfazendo

note: type: item
en: --switch-generation=@var{pattern}
pt_BR: --switch-generation=@var{padrão}

note: type: itemx
en: -S @var{pattern}
pt_BR: -S @var{padrão}

note: type: cindex
en: generations
pt_BR: gerações

note: type: item
en: --search-paths[=@var{kind}]
pt_BR: --search-paths[=@var{tipo}]

note: type: item
en: --profile=@var{profile}
pt_BR: --profile=@var{perfil}

note: type: itemx
en: -p @var{profile}
pt_BR: -p @var{perfil}

note: type: cindex
en: collisions, in a profile
pt_BR: colisões, em um perfil

note: type: item
en: --list-generations[=@var{pattern}]
pt_BR: --list-generations[=@var{padrão}]

note: type: itemx
en: -l [@var{pattern}]
pt_BR: -l [@var{padrão}]

note: type: section
en: Invoking @command{guix gc}
pt_BR: Invocando @command{guix gc}

note: type: cindex
en: garbage collector
pt_BR: coletor de lixo

note: type: item
en: --delete-generations[=@var{duration}]
pt_BR: --delete-generations[=@var{duração}]

note: type: section
en: Invoking @command{guix pull}
pt_BR: Invocando @command{guix pull}

note: type: itemx
en: --branch=@var{branch}
pt_BR: --branch=@var{ramo}

note: type: itemx
en: -C @var{file}
pt_BR: -C @var{arquivo}

note: type: itemx
en: -s @var{system}
pt_BR: -s @var{sistema}

note: type: section
en: Invoking @command{guix describe}
pt_BR: Invocando @command{guix describe}

note: type: section
en: Invoking @command{guix archive}
pt_BR: Invocando @command{guix archive}

note: type: cindex
en: archive
pt_BR: pacote

note: type: cindex
en: software development
pt_BR: desenvolvimento de software

note: type: item
en: container
pt_BR: recipiente

note: type: itemx
en: -u @var{user}
pt_BR: -u @var{usuário}

note: type: item
en: --expose=@var{source}[=@var{target}]
pt_BR: --expose=@var{fonte}[=@var{alvo}]

note: type: itemx
en: --share=@var{source}[=@var{target}]
pt_BR: --share=@var{fonte}[=@var{alvo}]

note: type: item
en: --root=@var{file}
pt_BR: --root=@var{arquivo}

note: type: itemx
en: -r @var{file}
pt_BR: -r @var{arquivo}

note: type: cindex
en: persistent environment
pt_BR: ambiente persistente

note: type: section
en: Invoking @command{guix environment}
pt_BR: Invocando @command{guix environment}

note: type: item
en: --load=@var{file}
pt_BR: --load=@var{arquivo}

note: type: itemx
en: -l @var{file}
pt_BR: -l @var{arquivo}

note: type: section
en: Invoking @command{guix pack}
pt_BR: Invocando @command{guix pack}

note: type: code{#1}
en: hash
pt_BR: hash (masc.)

note: type: item
en: #:substitutable?
pt_BR: #:substituível?

note: type: item
en: check
pt_BR: marcar

note: type: item
en: install
pt_BR: instalar

note: type: item
en: #$@var{obj}:@var{output}
pt_BR: #$@var{obj}:@var{saída}

note: type: itemx
en: (ungexp @var{obj} @var{output})
pt_BR: (ungexp @var{obj} @var{saída})

note: type: item
en: #$output[:@var{output}]
pt_BR: #$output[:@var{saída}]

note: type: itemx
en: (ungexp output [@var{output}])
pt_BR: (ungexp output [@var{saída}])

note: type: section
en: Invoking @command{guix repl}
pt_BR: Invocando @command{guix repl}

note: type: itemx
en: -t @var{type}
pt_BR: -t @var{tipo}

note: type: itemx
en: -L @var{directory}
pt_BR: -L @var{diretório}

note: type: item
en: --with-source=@var{source}
pt_BR: --with-source=@var{fonte}

note: type: itemx
en: --with-source=@var{package}=@var{source}
pt_BR: --with-source=@var{pacote}=@var{fonte}

note: type: item
en: --with-input=@var{package}=@var{replacement}
pt_BR: --with-input=@var{pacote}=@var{substituto}

note: type: item
en: --with-git-url=@var{package}=@var{url}
pt_BR: --with-git-url=@var{pacote}=@var{url}

note: type: item
en: --with-branch=@var{package}=@var{branch}
pt_BR: --with-branch=@var{pacote}=@var{ramo}

note: type: item
en: --with-commit=@var{package}=@var{commit}
pt_BR: --with-commit=@var{pacote}=@var{commit}

note: type: cindex
en: determinism, checking
pt_BR: determinismo, verificação

note: type: cindex
en: reproducibility, checking
pt_BR: reprodutibilidade, verificação

note: type: section
en: Invoking @command{guix edit}
pt_BR: Invocando @command{guix edit}

note: type: section
en: Invoking @command{guix download}
pt_BR: Invocando @command{guix download}

note: type: item
en: --output=@var{file}
pt_BR: --output=@var{arquivo}

note: type: itemx
en: -o @var{file}
pt_BR: -o @var{arquivo}

note: type: section
en: Invoking @command{guix hash}
pt_BR: Invocando @command{guix hash}

note: type: item
en: none
pt_BR: nenhuma

note: type: item
en: --lts-version=@var{version}
pt_BR: --lts-version=@var{versão}

note: type: itemx
en: -l @var{version}
pt_BR: -l @var{versão}

note: type: section
en: Invoking @command{guix refresh}
pt_BR: Invocando @command{guix refresh}

note: type: section
en: Invoking @command{guix lint}
pt_BR: Invocando @command{guix lint}

note: type: section
en: Invoking @command{guix size}
pt_BR: Invocando @command{guix size}

note: type: code{#1}
en: size
pt_BR: tamanho

note: type: item
en: self
pt_BR: próprio

note: type: item
en: --map-file=@var{file}
pt_BR: --map-file=@var{arquivo}

note: type: section
en: Invoking @command{guix graph}
pt_BR: Invocando @command{guix graph}

note: type: item
en: module
pt_BR: módulo

note: type: table
en: List the supported graph types.
pt_BR: Lista os tipos de gráficos disponíveis.

note: type: table
en: List the supported graph backends.
pt_BR: Lista os backends de gráficos disponíveis.

note: type: section
en: Invoking @command{guix publish}
pt_BR: Invocando @command{guix publish}

note: type: item
en: --port=@var{port}
pt_BR: --port=@var{porta}

note: type: itemx
en: -p @var{port}
pt_BR: -p @var{porta}

note: type: table
en: Listen for HTTP requests on @var{port}.
pt_BR: Ouve requisições HTTP na @var{porta}.

note: type: itemx
en: -r [@var{port}]
pt_BR: -r [@var{porta}]

note: type: section
en: Invoking @command{guix challenge}
pt_BR: Invocando @command{guix challenge}

note: type: section
en: Invoking @command{guix copy}
pt_BR: Invocando @command{guix copy}

note: type: section
en: Invoking @command{guix container}
pt_BR: Invocando @command{guix container}

note: type: section
en: Invoking @command{guix weather}
pt_BR: Invocando @command{guix weather}

note: type: item
en: --coverage[=@var{count}]
pt_BR: --coverage[=@var{contagem}]

note: type: itemx
en: -c [@var{count}]
pt_BR: -c [@var{contagem}]

note: type: section
en: Invoking @command{guix processes}
pt_BR: Invocando @command{guix processes}

note: type: code{#1}
en: operating-system
pt_BR: sistema operacional

note: type: Plain text
en: This example should be self-describing.  Some of the fields defined above, such as @code{host-name} and @code{bootloader}, are mandatory.  Others, such as @code{packages} and @code{services}, can be omitted, in which case they get a default value.
pt_BR: Este exemplo deve ser autodescritivo. Alguns dos campos definidos acima, como @code{host-name} e @code{bootloader}, são obrigatórios. Outros, como @code{packages} e @code{services}, podem ser omitidos; nesse caso, eles recebem um valor padrão.

note: type: Plain text
en: A graphical system with a choice of lightweight window managers instead of full-blown desktop environments would look like this:
pt_BR: Um sistema gráfico com uma escolha de gerenciadores de janelas leves em vez de ambientes de desktop completos teria a seguinte aparência:

note: type: Plain text
en: 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.
pt_BR: 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}.

note: type: code{#1}
en: label
pt_BR: rótulo

note: type: item
en: type
pt_BR: tipo

note: type: item
en: @code{check?} (default: @code{#t})
pt_BR: @code{check?} (padrão: @code{#t})

note: type: itemx
en: group
pt_BR: grupo

note: type: cindex
en: keyboard layout, definition
pt_BR: disposição do teclado, definição

note: type: cindex
en: XKB, keyboard layouts
pt_BR: XKB, disposições do teclado

note: type: cindex
en: keyboard layout, configuration
pt_BR: disposição do teclado, configuração

note: type: item
en: @code{remote?} (default: @code{#f})
pt_BR: @code{remote?} (padrão: @code{#f})

note: type: item
en: @code{no-issue?} (default: @code{#f})
pt_BR: @code{no-issue?} (padrão: @code{#f})

note: type: item
en: @code{no-clear?} (default: @code{#f})
pt_BR: @code{no-clear?} (padrão: @code{#f})

note: type: item
en: @code{no-newline?} (default: @code{#f})
pt_BR: @code{no-newline?} (padrão: @code{#f})

note: type: item
en: @code{hangup?} (default: @code{#f})
pt_BR: @code{hangup?} (padrão: @code{#f})

note: type: item
en: @code{no-hints?} (default: @code{#f})
pt_BR: @code{no-hints?} (padrão: @code{#f})

note: type: item
en: @code{persistent?} (default: @code{#t})
pt_BR: @code{persistent?} (padrão: @code{#t})

note: type: item
en: @code{shared?} (default: @code{#t})
pt_BR: @code{shared?} (padrão: @code{#t})

note: type: table
en: The GPM package to use.
pt_BR: O pacote GPM a ser usado.

note: type: item
en: @code{dbus?} (default: @code{#t})
pt_BR: @code{dbus?} (padrão: @code{#t})

note: type: item
en: @code{wait?} (default: @code{#t})
pt_BR: @code{wait?} (padrão: @code{#t})

note: type: item
en: @code{x11-forwarding?} (default: @code{#f})
pt_BR: @code{x11-forwarding?} (padrão: @code{#f})

note: type: item
en: @code{allow-agent-forwarding?} (default: @code{#t})
pt_BR: @code{allow-agent-forwarding?} (padrão: @code{#t})

note: type: item
en: @code{allow-tcp-forwarding?} (default: @code{#t})
pt_BR: @code{allow-tcp-forwarding?} (padrão: @code{#t})

note: type: item
en: @code{gateway-ports?} (default: @code{#f})
pt_BR: @code{gateway-ports?} (padrão: @code{#f})

note: type: item
en: @code{syslog-output?} (default: @code{#t})
pt_BR: @code{syslog-output?} (padrão: @code{#t})

note: type: item
en: @code{publish?} (default: @code{#t})
pt_BR: @code{publish?} (padrão: @code{#t})

note: type: item
en: @code{publish-workstation?} (default: @code{#t})
pt_BR: @code{publish-workstation?} (padrão: @code{#t})

note: type: item
en: @code{wide-area?} (default: @code{#f})
pt_BR: @code{wide-area?} (padrão: @code{#f})

note: type: cindex
en: keyboard layout, for Xorg
pt_BR: disposição do teclado, para Xorg

note: type: item
en: @code{watts-up-pro?} (default: @code{#f})
pt_BR: @code{watts-up-pro?} (padrão: @code{#f})

note: type: item
en: @code{poll-batteries?} (default: @code{#t})
pt_BR: @code{poll-batteries?} (padrão: @code{#t})

note: type: item
en: @code{ignore-lid?} (default: @code{#f})
pt_BR: @code{ignore-lid?} (padrão: @code{#f})

note: type: item
en: @code{port} (default: @code{3306})
pt_BR: @code{porta} (default: @code{3306})

note: type: item
en: @code{port} (default: @code{6379})
pt_BR: @code{porta} (default: @code{6379})

note: type: cindex
en: email
pt_BR: e-mail

note: type: table
en: Message-ID
pt_BR: Mensagem-ID

note: type: table
en: Subject
pt_BR: Assunto

note: type: table
en: username
pt_BR: nome de usuário

note: type: table
en: recipient
pt_BR: destinatário

note: type: itemx
en: @code{port} (default: @code{6667})
pt_BR: @code{porta} (default: @code{6667})

note: type: cindex
en: telephony, services
pt_BR: telefonia, serviços

note: type: item
en: @code{port} (default: @code{64738})
pt_BR: @code{porta} (default: @code{64738})

note: type: item
en: @code{remember-channel?} (default: @code{#f})
pt_BR: @code{remember-channel?} (padrão: @code{#f})

note: type: item
en: @code{bonjour?} (default: @code{#f})
pt_BR: @code{bonjour?} (padrão: @code{#f})

note: type: itemx
en: password
pt_BR: senha

note: type: item
en: @code{port} (default: @code{"667"})
pt_BR: @code{porta} (default: @code{"667"})

note: type: code{#1}
en: contents
pt_BR: conteúdo

note: type: code{#1}
en: body
pt_BR: corpo

note: type: Plain text
en: ...@: and much more.
pt_BR: ...@: e muito mais.

note: type: item
en: @code{deny?} (default: @code{#f})
pt_BR: @code{deny?} (padrão: @code{#f})

note: type: item
en: @code{nsec3?} (default: @code{#f})
pt_BR: @code{nsec3?} (padrão: @code{#f})

note: type: item
en: @code{no-hosts?} (default: @code{#f})
pt_BR: @code{no-hosts?} (padrão: @code{#f})

note: type: item
en: @code{port} (default: @code{53})
pt_BR: @code{porta} (default: @code{53})

note: type: item
en: @code{no-resolv?} (default: @code{#f})
pt_BR: @code{no-resolv?} (padrão: @code{#f})

note: type: item
en: @code{negative-cache?} (default: @code{#t})
pt_BR: @code{negative-cache?} (padrão: @code{#t})

note: type: item
en: @code{port} (default: @code{8081})
pt_BR: @code{porta} (default: @code{8081})

note: type: item
en: @code{fallback?} (default: @code{#f})
pt_BR: @code{fallback?} (padrão: @code{#f})

note: type: item
en: @code{port} (default: @code{"6600"})
pt_BR: @code{porta} (default: @code{"6600"})

note: type: table
en: output to a file, with the given filepath
pt_BR: saída para um arquivo, com o caminho de arquivo dado

note: type: defvr
en: Service type for the QEMU guest agent service.
pt_BR: Tipo de serviço para o serviço de agente convidado QEMU.

note: type: item
en: @code{rc-file} (default: @var{(gitolite-rc-file)})
pt_BR: @code{rc-file} (padrão: @var{(gitolite-rc-file)})

note: type: cindex
en: Gitile service
pt_BR: Serviço Gitile

note: type: item
en: @code{port} (default: @code{15000})
pt_BR: @code{porta} (default: @code{15000})

note: type: item
en: @code{device} (default: @code{"/dev/ttyS0"})
pt_BR: @code{device} (padrão: @code{"/dev/ttyS0"})

note: type: cindex
en: dictionary
pt_BR: dicionário

note: type: cindex
en: X.509 certificates
pt_BR: Certificados X.509

note: type: cindex
en: keyboard layout, for the bootloader
pt_BR: disposição do teclado, para o gerenciador de boot

note: type: item
en: search
pt_BR: pesquisa

note: type: item
en: debug
pt_BR: depuração

note: type: table
en: The command:
pt_BR: O comando:

note: type: section
en: Running Guix in a Virtual Machine
pt_BR: Usando o Guix em uma Máquina Virtual

note: type: item
en: @code{respawn?} (default: @code{#t})
pt_BR: @code{respawn?} (padrão: @code{#t})

note: type: code{#1}
en: start
pt_BR: iniciar

note: type: section
en: Configuring the Shell
pt_BR: Configurando o "Shell"

note: type: subsection
en: Essential Home Services
pt_BR: Serviços essenciais domésticos

note: type: menuentry
en: Scheduled User's Job Execution.
pt_BR: Execução de trabalho do Usuário agendado.

note: type: cindex
en: provenance tracking, of the home environment
pt_BR: rastreamento de proveniência, do ambiente doméstico

note: type: chapter
en: Porting to a New Platform
pt_BR: Portando para uma nova plataforma

note: type: include
en: contributing.texi
pt_BR: contributing.pt_BR.texi

note: type: Plain text
en: The Nix-based software distributions, Nixpkgs and NixOS, have also been an inspiration for Guix.
pt_BR: As distribuições de software baseadas em Nix, Nixpkgs e NixOS, também foram uma inspiração para o Guix.

note: type: Plain text
en: 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!
pt_BR: 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!

note: type: cindex
en: license, GNU Free Documentation License
pt_BR: licença, Licença de Documentação Livre GNU
