# Chinese (simplified) translation of the Guix manual.
# Copyright (C) 2013-2019 the authors of Guix (msgids) and the following authors (msgstr)
# This file is distributed under the same license as the guix manual package.
# Meiyo Peng <meiyo@riseup.net>, 2019.
# 郑俊杰 <873216071@qq.com>, 2021, 2023, 2024.
# Liu Tao <lyuutau@outlook.com>, 2021, 2023.
# Xinglu Chen <public@yoctocell.xyz>, 2021.
# Charles Lee <lchopn@gmail.com>, 2021.
# Went He <1437061699@qq.com>, 2021, 2023.
# Whired Planck <fungdaat31@outlook.com>, 2022.
# chin housin <sharingfun@163.com>, 2022.
# Julien Lepiller <fedora-account@lepiller.eu>, 2022.
# Yang Yulin <yylteam@icloud.com>, 2022.
# Thomas Cheng <orangecza@gmail.com>, 2023.
# Hilton Chain <yareli@ultrarare.space>, 2023.
# Yi Cao <cygauss@outlook.com>, 2023.
# Burgess Chang <bsc@brsvh.org>, 2023.
# Florian Pelz <pelzflorian@pelzflorian.de>, 2023, 2024, 2025.
# a x <meruarasu@email1.io>, 2023, 2025.
# Integral <integral@member.fsf.org>, 2024.
# Celestial y <clsty@celestialy.top>, 2024, 2025.
# Weblate Translation Memory <noreply-mt-weblate-translation-memory@weblate.org>, 2024, 2025.
# voyage 200 <hello_cmd@outlook.com>, 2024.
# Miku Nakano <jinleho@hotmail.com>, 2025.
# rw flurando <2024110144@mails.szu.edu.cn>, 2025.
# Rivulet Cedar <ls-shandong@users.noreply.translate.fedoraproject.org>, 2025.
# Poesty Li <poesty7450@gmail.com>, 2025.
# Rivulet Cedar <rivulet_cedar@yeah.net>, 2025.
msgid ""
msgstr ""
"Project-Id-Version: guix-manual 1.0.1-pre1\n"
"Report-Msgid-Bugs-To: bug-guix@gnu.org\n"
"POT-Creation-Date: 2026-03-15 03:18+0000\n"
"PO-Revision-Date: 2026-03-26 17:03+0000\n"
"Last-Translator: pelzflorian <pelzflorian@noreply.codeberg.org>\n"
"Language-Team: Chinese (Simplified Han script) <https://translate.codeberg.org/projects/guix/documentation-manual/zh_Hans/>\n"
"Language: zh_CN\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Weblate 5.16.2\n"
"X-Bugs: Report translation errors to the Language-Team address.\n"

msgid "Contributing"
msgstr "贡献"

msgid "This project is a cooperative effort, and we need your help to make it grow! Please get in touch with us on @email{guix-devel@@gnu.org} and @code{#guix} on the Libera Chat IRC network.  We welcome ideas, bug reports, patches, and anything that may be helpful to the project.  We particularly welcome help on packaging (@pxref{Packaging Guidelines})."
msgstr "这个项目是大家合作的成果，需要你的帮助才能发展壮大！请通过 @email{guix-devel@@gnu.org} 和 Libera Chat IRC 上的 @code{#guix} 联系我们。我们欢迎各种想法、bug 反馈、补丁以及任何对项目有帮助的内容，尤其是打包方面的帮助(@pxref{Packaging Guidelines})."

msgid "code of conduct, of contributors"
msgstr "贡献者行为准则"

msgid "contributor covenant"
msgstr "贡献者契约"

msgid "We want to provide a warm, friendly, and harassment-free environment, so that anyone can contribute to the best of their abilities.  To this end our project uses a ``Contributor Covenant'', which was adapted from @url{https://contributor-covenant.org/}.  You can find a local version in the @file{CODE-OF-CONDUCT} file in the source tree."
msgstr "我们希望提供一个温暖、友好、无骚扰的环境，让任何人都能尽其所能贡献。为此，我们的项目采用了“贡献者契约”，该契约改编自 @url{https://contributor-covenant.org/}。在源代码目录里的 @file{CODE-OF-CONDUCT} 文件中可以找到一份本地版。"

msgid "Contributors are not required to use their legal name in patches and on-line communication; they can use any name or pseudonym of their choice."
msgstr "贡献者不必在提交补丁和在线交流时使用法定姓名。他们可以使用自己选择的任何名字或者笔名。"

msgid "Requirements"
msgstr "需求"

msgid "Software needed to build and run Guix."
msgstr "构建和运行 Guix 需要的软件。"

msgid "Building from Git"
msgstr "从 Git 构建"

msgid "The latest and greatest."
msgstr "最新的并且最好的。"

msgid "Running the Test Suite"
msgstr "运行测试套件"

msgid "Testing Guix."
msgstr "测试 Guix。"

msgid "Running Guix Before It Is Installed"
msgstr "在安装之前运行 Guix"

msgid "Hacker tricks."
msgstr "黑客技巧。"

msgid "The Perfect Setup"
msgstr "完美的配置"

msgid "The right tools."
msgstr "正确的工具。"

msgid "Source Tree Structure"
msgstr "源码树结构"

msgid "Source code guided tour."
msgstr "源码导览。"

msgid "Packaging Guidelines"
msgstr "打包指导"

msgid "Growing the distribution."
msgstr "帮助发行版成长。"

msgid "Coding Style"
msgstr "代码风格"

msgid "Hygiene of the contributor."
msgstr "贡献者代码卫生守则。"

msgid "Submitting Patches"
msgstr "提交补丁"

msgid "Share your work."
msgstr "分享你的工作。"

msgid "Tracking Bugs and Changes"
msgstr "跟踪程序漏洞及改动"

msgid "Keeping it all organized."
msgstr "保持井井有条。"

msgid "Teams"
msgstr "团队"

msgid "Coordinating efforts."
msgstr "协调努力。"

msgid "Making Decisions"
msgstr "做出决定"

msgid "Collectively choosing the way forward."
msgstr "共同选择前进的方向。"

msgid "Commit Access"
msgstr "提交权利"

msgid "Pushing to the official repository."
msgstr "推送到官方仓库。"

msgid "Reviewing the Work of Others"
msgstr "审阅他人的工作"

msgid "Some guidelines for sharing reviews."
msgstr "分享评论的一些指导方针。"

msgid "Updating the Guix Package"
msgstr "更新 Guix 软件包"

msgid "Updating the Guix package definition."
msgstr "更新 Guix 的软件包定义。"

msgid "Deprecation Policy"
msgstr "弃用策略"

msgid "Commitments and tools for deprecation."
msgstr "用于弃用的提交和工具。"

msgid "Writing Documentation"
msgstr "撰写文档"

msgid "Improving documentation in GNU Guix."
msgstr "完善 GNU Guix 中的文档。"

msgid "Translating Guix"
msgstr "翻译 Guix"

msgid "Make Guix speak your native language."
msgstr "用您的母语翻译 Guix。"

msgid "Contributing to Guix's Infrastructure"
msgstr "为 Guix 的基础设施做贡献"

msgid "Make Guix ecosystem work better."
msgstr "让 Guix 生态系统更好地运作。"

msgid "You can easily hack on Guix itself using Guix and Git, which we use for version control (@pxref{Building from Git})."
msgstr "你可以轻松地使用 Guix 和 Git 来折腾 Guix 本身，我们将其用于版本控制。(@pxref{Building from Git})."

msgid "But when packaging Guix for foreign distros or when bootstrapping on systems without Guix, and if you decide to not just trust and install our readily made binary (@pxref{Binary Installation}), you can download a release version of our reproducible source tarball and read on."
msgstr "但是，在为外国发行版打包 Guix 或在没有 Guix 的系统上引导时，如果您决定不要直接信任并安装我们现成的二进制文件（@pxref{Binary Installation}），您可以下载一份我们可复现的源码包的发布版并继续阅读。"

msgid "This section lists requirements when building Guix from source.  The build procedure for Guix is the same as for other GNU software, and is not covered here.  Please see the files @file{README} and @file{INSTALL} in the Guix source tree for additional details."
msgstr "这个小节列举了从源代码构建 Guix 的要求。构建 Guix 的步骤和其它 GNU 软件相同，这里不介绍。请阅读 Guix 源码树里的 @file{README} 和 @file{INSTALL} 文件以了解更多细节。"

msgid "official website"
msgstr "官方网站"

msgid "GNU Guix is available for download from its website at @url{https://guix.gnu.org}."
msgstr "GNU Guix 可以从它的网站下载 @url{https://guix.gnu.org}。"

msgid "GNU Guix depends on the following packages:"
msgstr "GNU Guix 依赖以下软件包："

msgid "@url{https://gnu.org/software/guile/, GNU Guile}, version 3.0.x,"
msgstr "@url{https://gnu.org/software/guile/, GNU Guile}，版本 3.0.x，"

msgid "version 3.0.9 or later;"
msgstr "版本 3.0.9 或更新；"

msgid "@url{https://codeberg.org/guile-gcrypt/guile-gcrypt, Guile-Gcrypt}, version"
msgstr "@url{https://codeberg.org/guile-gcrypt/guile-gcrypt, Guile-Gcrypt}，版本"

msgid "0.1.0 or later;"
msgstr "0.1.0 或更新；"

msgid "@uref{https://gitlab.com/gnutls/guile/, Guile-GnuTLS} (@pxref{Guile Preparations, how to install the GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile})@footnote{The Guile bindings to @uref{https://gnutls.org/, GnuTLS} were distributed as part of GnuTLS until version 3.7.8 included.};"
msgstr "@uref{https://gitlab.com/gnutls/guile/, Guile-GnuTLS}（@pxref{Guile Preparations, 如何为 Guile 安装 GnuTLS 绑定, gnutls-guile, GnuTLS-Guile}）@footnote{关于 @uref{https://gnutls.org/, GnuTLS} 的 Guile 绑定作为 GnuTLS 直到（含）版本 3.7.8 的一部分分发。}；"

msgid "@uref{https://codeberg.org/guile-sqlite3/guile-sqlite3, Guile-SQLite3}, version 0.1.0 or later;"
msgstr "@uref{https://codeberg.org/guile-sqlite3/guile-sqlite3, Guile-SQLite3}, 版本 0.1.0 或更新；"

msgid "version 0.1.0 or later;"
msgstr "版本 0.1.0 或更新；"

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

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

msgid "@uref{https://gitlab.com/guile-git/guile-git, Guile-Git}, version 0.10.0 or later;"
msgstr "@uref{https://gitlab.com/guile-git/guile-git, Guile-Git}，版本 0.10.0 或更新；"

msgid "@uref{https://git-scm.com, Git} (yes, both!);"
msgstr "@uref{https://git-scm.com, Git}（是的，两个都是！）；"

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

msgid "4.3.0 or later;"
msgstr "4.3.0 或更新；"

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

msgid "The following dependencies are optional:"
msgstr "这些依赖是可选的："

msgid "Support for build offloading (@pxref{Daemon Offload Setup}) and @command{guix copy} (@pxref{Invoking guix copy}) depends on @uref{https://github.com/artyom-poptsov/guile-ssh, Guile-SSH}, version 0.13.0 or later."
msgstr "对构建下发（@pxref{Daemon Offload Setup}）和 @command{guix copy} （@pxref{Invoking guix copy}）的支持依赖于 @uref{https://github.com/artyom-poptsov/guile-ssh, Guile-SSH}，版本 0.13.0 或更新。"

msgid "@uref{https://ngyro.com/software/guile-semver.html, Guile-Semver} for the @code{crate} importer (@pxref{Invoking guix import})."
msgstr "@uref{https://ngyro.com/software/guile-semver.html, Guile-Semver} 用于 @code{crate} 导入器（@pxref{Invoking guix import}）。"

msgid "@uref{https://www.nongnu.org/guile-lib/doc/ref/htmlprag/, Guile-Lib} for the @code{go} importer (@pxref{Invoking guix import}) and for some of the ``updaters'' (@pxref{Invoking guix refresh})."
msgstr "@uref{https://www.nongnu.org/guile-lib/doc/ref/htmlprag/, Guile-Lib} 用于 @code{go} 导入器（@pxref{Invoking guix import}）以及一些“升级器”（@pxref{Invoking guix refresh}）。"

msgid "When @url{http://www.bzip.org, libbz2} is available, @command{guix-daemon} can use it to compress build logs."
msgstr "当 @url{http://www.bzip.org, libbz2} 可用时，@command{guix-daemon} 可以用它来压缩构建日志。"

msgid "Unless @option{--disable-daemon} was passed to @command{configure}, the following packages are also needed:"
msgstr "除非 @option{--disable-daemon} 被传给 @command{configure}，以下软件包也被需要："

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

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

msgid "@url{https://gcc.gnu.org, GCC's g++}, with support for the"
msgstr "@url{https://gcc.gnu.org, GCC's g++}，带有支持对于"

msgid "C++11 standard."
msgstr "C++11 标准。"

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

msgid "authentication, of a Guix checkout"
msgstr "Guix 签出的身份认证"

msgid "How do you ensure that you obtained a genuine copy of the repository? To do that, run @command{guix git authenticate}, passing it the commit and OpenPGP fingerprint of the @dfn{channel introduction} (@pxref{Invoking guix git authenticate}):"
msgstr "如何确保已获得存储库的真实副本？为此请运行 @command{guix git authenticate}，将 @dfn{channel introduction}（@pxref{Invoking guix git authenticate}）的提交和 OpenPGP 指纹传给它："

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

msgid "This command completes with exit code zero on success; it prints an error message and exits with a non-zero code otherwise."
msgstr "此命令完成后，若成功则退出代码为零；否则打印一条错误消息，以非零代码退出。"

msgid "As you can see, there is a chicken-and-egg problem: you first need to have Guix installed.  Typically you would install Guix System (@pxref{System Installation}) or Guix on top of another distro (@pxref{Binary Installation}); in either case, you would verify the OpenPGP signature on the installation medium.  This ``bootstraps'' the trust chain."
msgstr "正如你所看到的，这里存在一个先决条件的问题：你首先需要安装 Guix。典型地，你会安装 Guix 系统（@pxref{System Installation}）或在 另一个发行版上安装 Guix（@pxref{Binary Installation}）；无论哪种情况，你 都需要在安装介质上验证 OpenPGP 签名。这“引导”了信任链。"

msgid "The easiest way to set up a development environment for Guix is, of course, by using Guix! The following command starts a new shell where all the dependencies and appropriate environment variables are set up to hack on Guix:"
msgstr "设置 Guix 开发环境的最简单的方式当然是使用 Guix！下面这些命令启动一个 shell，所有的依赖和环境变量都为折腾 Guix 设置好了："

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

msgid "or even, from within a Git worktree for Guix:"
msgstr "或者，从一个 Git worktree 内部使用 Guix："

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

msgid "If @option{-C} (short for @option{--container}) is not supported on your system, try @command{--pure} instead of @option{-CPW}.  @xref{Invoking guix shell}, for more information on that command."
msgstr "如果 @option{-C}（@option{--container} 的缩写）在你的系统上不被支持，请尝试使用 @command{--pure} 来代替 @option{-CPW}。有关该命令的更多信息见 @xref{Invoking guix shell}."

msgid "If you are unable to use Guix when building Guix from a checkout, the following are the required packages in addition to those mentioned in the installation instructions (@pxref{Requirements})."
msgstr "如果在从检出中构建 Guix 时无法使用 Guix，则除了安装说明中提到的 软件包（@pxref{Requirements}）外，以下是所需的软件包。"

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

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

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

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

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

msgid "@url{https://www.gnu.org/software/help2man/, GNU Help2man (optional)}."
msgstr "@url{https://www.gnu.org/software/help2man/, GNU Help2man（可选）}。"

msgid "On Guix, other development tools, like @code{strace}, can be included by giving them as extra arguments to @command{guix shell}:"
msgstr "在 Guix 上，其它的开发工具，如 @code{strace}， 可以将它们作为额外的参数包含到 @command{guix shell} 中。"

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

msgid "From there you can generate the build system infrastructure using Autoconf and Automake:"
msgstr "在这里你可以使用 Autoconf 和 Automake 生成构建系统的基础设施："

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

msgid "If you get an error like this one:"
msgstr "若你得到一个像这样的错误："

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

msgid "it probably means that Autoconf couldn’t find @file{pkg.m4}, which is provided by pkg-config.  Make sure that @file{pkg.m4} is available.  The same holds for the @file{guile.m4} set of macros provided by Guile.  For instance, if you installed Automake in @file{/usr/local}, it wouldn’t look for @file{.m4} files in @file{/usr/share}.  In that case, you have to invoke the following command:"
msgstr "它可能意味着 Autoconf 无法找到由 pkg-config 提供的 @file{pkg.m4}。请确保 @file{pkg.m4} 可用。由 Guile 提供的 @file{guile.m4} 宏也类似。假如你的 Automake 安装在 @file{/usr/local}，那么它不会从 @file{/usr/share} 里寻找 @file{.m4} 文件。这种情况下，你必须执行下面这个命令："

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

msgid "@xref{Macro Search Path,,, automake, The GNU Automake Manual}, for more information."
msgstr "更多信息请参考 @xref{Macro Search Path,,, automake, The GNU Automake Manual}."

msgid "state directory"
msgstr "state 目录"

msgid "localstatedir"
msgstr "localstatedir"

msgid "system configuration directory"
msgstr "系统配置目录"

msgid "sysconfdir"
msgstr "sysconfdir"

msgid "Then, run:"
msgstr "然后，运行："

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

msgid "Optionally, @code{--localstatedir} and @code{--sysconfdir} can also be provided as arguments.  By default, @code{localstatedir} is @file{/var} (@pxref{The Store}, for information about this) and @code{sysconfdir} is @file{/etc}.  Note that you will probably not run @command{make install} at the end (you don't have to) but it's still important to pass the right @code{localstatedir} and @code{sysconfdir} values, which get recorded in the @code{(guix config)} Guile module."
msgstr "如果你愿意，@code{--localstatedir} 和 @code{--sysconfdir} 也能作为参数被提供。在默认情况下，@code{localstatedir} 是 @file{/var}（如欲了解更多信息，@pxref{The Store}）和 @code{sysconfdir} 是 @file{/etc}。请注意，即使最后不运行 @command{make install}（因为没有必要），传递正确的 @code{localstatedir} 和 @code{sysconfdir} 参数值依然是重要的，因为它们会被记录在 Guile 的 @code{(guix config)} 模块内。"

msgid "Finally, you can build Guix and, if you feel so inclined, run the tests (@pxref{Running the Test Suite}):"
msgstr "最后，你可以构建 Guix。若你希望，还可以运行测试 (@pxref{运行测试套件}）："

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

msgid "If anything fails, take a look at installation instructions (@pxref{Installation}) or send a message to the @email{guix-devel@@gnu.org, mailing list}."
msgstr "如果遇到任何错误，请参考“安装指导”（@pxref{Installation}）或者给@email{guix-devel@@gnu.org, 邮件列表}发邮件。"

msgid "From there on, you can authenticate all the commits included in your checkout by running:"
msgstr "从这开始，你可以运行下面的命令认证检出中的所有提交："

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

msgid "The first run takes a couple of minutes, but subsequent runs are faster.  On subsequent runs, you can run the command without any arguments since the @dfn{introduction} (the commit ID and OpenPGP fingerprints above)  will have been recorded@footnote{This requires a recent version of Guix, from May 2024 or more recent.}:"
msgstr "第一次运行需要几分钟，但后续运行会更快。在后续运行中，您可以不带任何参数运行命令，因为 @dfn{介绍}（上面的提交 ID 和 OpenPGP 指纹）将被记录@footnote{这需要 2024 年 5 月或更高版本的 Guix。}："

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

msgid "When your configuration for your local Git repository doesn't match the default one, you can provide the reference for the @code{keyring} branch @i{via} the @option{-k} option.  The following example assumes that you have a Git remote called @samp{myremote} pointing to the official repository:"
msgstr "或者，当你的本地 Git 仓库与默认的不符时，你可以通过环境变量 @code{GUIX_GIT_KEYRING} 提供一个对@code{keyring} 分支的引用。下面的例子假设你有一个名为 @samp{myremote} 的 Git 远程分支，它指向官方仓库："

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

msgid "@xref{Invoking guix git authenticate}, for more information on this command."
msgstr "@xref{Invoking guix git authenticate}，以获得关于此命令的更多信息。"

msgid "Note"
msgstr "注"

msgid "By default, hooks are installed such that @command{guix git authenticate} is invoked anytime you run @command{git pull} or @command{git push}."
msgstr "钩子被默认配置以便在@command{git pull} 或 @command{git push}运行时自动调用 @command{guix git authenticate}."

msgid "After updating the repository, @command{make} might fail with an error similar to the following example:"
msgstr "在每次更新仓库后，@command{make} 可能会因为一个错误而失败，就像下面的例子："

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

msgid "This means that one of the record types that Guix defines (in this example, the @code{origin} record) has changed, and all of guix needs to be recompiled to take that change into account.  To do so, run @command{make clean-go} followed by @command{make}."
msgstr "它的意思是 Guix 定义的一个记录类型变动了（在这个例子中，为 @code{origin} 记录），并且全部 guix 都需要重编译来让这个变动生效。运行 @command{make clean-go} 和 @command{make} 来重新编译。"

msgid "Should @command{make} fail with an Automake error message after updating, you need to repeat the steps outlined in this section, commencing with @command{./bootstrap}."
msgstr "如果 @command{make} 在更新后伴随着 Automake 报错而失败，您需要重复本节中概述的步骤，从 @command{./bootstrap} 开始。"

msgid "test suite"
msgstr "测试套件"

msgid "After a successful @command{configure} and @code{make} run, it is a good idea to run the test suite.  It can help catch issues with the setup or environment, or bugs in Guix itself---and really, reporting test failures is a good way to help improve the software.  To run the test suite, type:"
msgstr "成功执行 @command{configure} 和 @code{make} 之后，最好运行测试套件。它可以帮助查找设置和环境的错误，或者是 Guix 自身的 bug－－并且，报告测试错误是帮助改进软件的好方法。输入下面的命令以运行测试套件："

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

msgid "Test cases can run in parallel: you can use the @code{-j} option of GNU@tie{}make to speed things up.  The first run may take a few minutes on a recent machine; subsequent runs will be faster because the store that is created for test purposes will already have various things in cache."
msgstr "测试用例可以并行运行：你可以用 GNU@tie{}make 的 @code{-j} 参数来加速运行。在一台较新的机器上第一次运行可能会花几分钟，后续的运行会更快，因为为测试创建的仓库已经包含了各种缓存。"

msgid "It is also possible to run a subset of the tests by defining the @code{TESTS} makefile variable as in this example:"
msgstr "你还可以通过定义 makefile 的 @code{TESTS} 变量来运行测试的一个子集，如同以下示例："

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

msgid "By default, tests results are displayed at a file level.  In order to see the details of every individual test cases, it is possible to define the @code{SCM_LOG_DRIVER_FLAGS} makefile variable as in this example:"
msgstr "默认情况下，测试结果只展示到文件层级。为了查看每个独立的测试用例的详情，可以像这样定义 @code{SCM_LOG_DRIVER_FLAGS} makefile 变量："

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

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

msgid "Those wishing to inspect the results of failed tests directly from the command line can add the @option{--errors-only=yes} option to the @code{SCM_LOG_DRIVER_FLAGS} makefile variable and set the @code{VERBOSE} Automake makefile variable, as in:"
msgstr "那些希望直接通过命令行检查失败测试结果的用户可以将 @option{--errors-only=yes} 选项添加到 @code{SCM_LOG_DRIVER_FLAGS} makefile 变量中，并设置 @code{VERBOSE} Automake makefile 变量，如下所示："

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

msgid "The @option{--show-duration=yes} option can be used to print the duration of the individual test cases, when used in combination with @option{--brief=no}:"
msgstr "当与 @option{--brief=no} 结合使用时，可以使用 @option{--show-duration=yes} 选项来输出单个测试用例的持续时间："

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

msgid "Upon failure, please email @email{bug-guix@@gnu.org} and attach the @file{test-suite.log} file.  Please specify the Guix version being used as well as version numbers of the dependencies (@pxref{Requirements}) in your message."
msgstr "遇到错误时，请给 @email{bug-guix@@gnu.org} 发邮件，并附带 @file{test-suite.log} 文件。请在消息里说明使用的 Guix 的版本信息和依赖（@pxref{Requirements}）的版本信息。"

msgid "Guix also comes with a whole-system test suite that tests complete Guix System instances.  It can only run on systems where Guix is already installed, using:"
msgstr "Guix 还附带了一个可以测试整个 Guix 系统实例的全系统测试套件。它只能在已经安装 Guix 的系统上运行，使用："

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

msgid "or, again, by defining @code{TESTS} to select a subset of tests to run:"
msgstr "或者再次，通过定义 @code{TESTS} 选择测试的一个子集来运行："

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

msgid "These system tests are defined in the @code{(gnu tests @dots{})} modules.  They work by running the operating systems under test with lightweight instrumentation in a virtual machine (VM).  They can be computationally intensive or rather cheap, depending on whether substitutes are available for their dependencies (@pxref{Substitutes}).  Some of them require a lot of storage space to hold VM images."
msgstr "这些系统测试在 @code{(gnu tests @dots{})} 模块中定义。原理是，在一个虚拟机（virtual machine, VM）中，以轻量级的仪表运行待测试的操作系统。它们的计算密集程度可能很高，也可能相对较低，这取决于其依赖项是否有 substitues 可用（@pxref{Substitutes}）。其中一些需要大量存储空间来保存 VM 镜像。"

msgid "If you encounter an error like:"
msgstr "若你遇到一个像这样的错误："

msgid ""
"Compiling Scheme modules...\n"
"ice-9/eval.scm:142:16: In procedure compile-top-call:\n"
"error: all-system-tests: unbound variable\n"
"hint: Did you forget `(use-modules (gnu tests))'?\n"
msgstr ""
"Compiling Scheme modules...\n"
"ice-9/eval.scm:142:16: In procedure compile-top-call:\n"
"error: all-system-tests: unbound variable\n"
"提示：你是否忘记了 `(use-modules (gnu tests))'？\n"

msgid "there may be inconsistencies in the work tree from previous builds.  To resolve this, try running @command{make clean-go} followed by @command{make}."
msgstr "工作树中可能存在来自先前构建的不一致处。要解决此问题，尝试运行 @command{make clean-go}，再运行 @command{make}。"

msgid "Again in case of test failures, please send @email{bug-guix@@gnu.org} all the details."
msgstr "再次，若遇到测试错误，请向 @email{bug-guix@@gnu.org} 发送所有细节信息。"

msgid "In order to keep a sane working environment, you will find it useful to test the changes made in your local source tree checkout without actually installing them.  So that you can distinguish between your ``end-user'' hat and your ``motley'' costume."
msgstr "为了保持一个正常的工作环境，你会发现在不实际安装的情况下测试本地源码树签出中的更改是非常有用的。这样你可以更好地区分自己作为“最终用户”和“测试员”的角色。"

msgid "To that end, all the command-line tools can be used even if you have not run @code{make install}.  To do that, you first need to have an environment with all the dependencies available (@pxref{Building from Git}), and then simply prefix each command with @command{./pre-inst-env} (the @file{pre-inst-env} script lives in the top build tree of Guix; @pxref{Building from Git} to generate it).  As an example, here is how you would build the @code{hello} package as defined in your working tree (this assumes @command{guix-daemon} is already running on your system; it's OK if it's a different version):"
msgstr "这样，即使你没有运行 @code{make install}，所有的命令行工具都可以使用。为此，你先要有一个全部依赖都可用的环境（@pxref{从 Git 构建}），然后简单地为每个命令添加前缀 @command{./pre-inst-env}（@file{pre-inst-env} 脚本在 Guix 构建树的最顶层，@pxref{从 Git 构建}来生成它）。作为例子，以下是你如何构建 @code{hello} 包，如同在你的工作树中定义的那样（这假设了 @command{guix-daemon} 正在运行于你的系统上；如果是不同的版本也可以）："

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

msgid "Similarly, an example for a Guile session using the Guix modules:"
msgstr "类似地，一个使用 Guix 模块的 Guile 会话的例子："

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

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

msgid "REPL"
msgstr "REPL"

msgid "read-eval-print loop"
msgstr "读取 - 估值 - 打印（read-eval-print）循环"

msgid "@dots{} and for a REPL (@pxref{Using Guix Interactively}):"
msgstr "@dots{} 以及为了一个 REPL（@pxref{Using Guix Interactively}）："

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

msgid "If you are hacking on the daemon and its supporting code or if @command{guix-daemon} is not already running on your system, you can launch it straight from the build tree@footnote{The @option{-E} flag to @command{sudo} guarantees that @code{GUILE_LOAD_PATH} is correctly set such that @command{guix-daemon} and the tools it uses can find the Guile modules they need.}:"
msgstr "如果你在折腾守护进程及其支持代码，或者 @command{guix-daemon} 尚未在系统中运行，你可以直接从构建树中启动它@footnote{@command{sudo} 的 @option{-E} 选项保证了 @code{GUILE_LOAD_PATH} 被正确设置，以便 @command{guix-daemon} 及其使用的工具可以找到它们所需的 Guile 模块。}："

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

msgid "The @command{pre-inst-env} script sets up all the environment variables necessary to support this, including @env{PATH} and @env{GUILE_LOAD_PATH}."
msgstr "@command{pre-inst-env} 脚本设置好了为了支持这个的所有必要的环境变量，包括 @env{PATH} 和 @env{GUILE_LOAD_PATH}。"

msgid "Note that @command{./pre-inst-env guix pull} does @emph{not} upgrade the local source tree; it simply updates the @file{~/.config/guix/current} symlink (@pxref{Invoking guix pull}).  Run @command{git pull} instead if you want to upgrade your local source tree."
msgstr "注意，@command{./pre-inst-env guix pull} @emph{不}会更新本地源代码树；它只是简单地更新 @file{~/.config/guix/current} 符号链接（@pxref{Invoking guix pull}）。如果你想更新本地源码树，请运行 @command{git pull}。"

msgid "Sometimes, especially if you have recently updated your repository, running @command{./pre-inst-env} will print a message similar to the following example:"
msgstr "有时，特别是刚刚更新过你的仓库时，运行 @command{./pre-inst-env} 将会打印一个消息，类似于下面的例子："

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

msgid "This is only a note and you can safely ignore it.  You can get rid of the message by running @command{make -j4}.  Until you do, Guile will run slightly slower because it will interpret the code instead of using prepared Guile object (@file{.go}) files."
msgstr "这仅仅是一个提示，你可以安全地忽略它，可以通过运行 @command{make -j4} 来避免这条消息。若你不这么做，Guile 就会运行的稍微慢一些，因为它会解释代码而不是使用预备的 Guile 对象 (@file{.go}) 文件。"

msgid "You can run @command{make} automatically as you work using @command{watchexec} from the @code{watchexec} package.  For example, to build again each time you update a package file, run @samp{watchexec -w gnu/packages -- make -j4}."
msgstr "你可以使用 @code{watchexec} 包中的 @command{watchexec} 在你干活时自动运行 @command{make}。例如，若要在每次更新一个包文件后都再次构建，运行@samp{watchexec -w gnu/packages -- make -j4}."

msgid "Guile Studio"
msgstr "Guile Studio"

msgid "Vim and NeoVim"
msgstr "Vim 和 NeoVim"

msgid "Geiser allows for interactive and incremental development from within Emacs: code compilation and evaluation from within buffers, access to on-line documentation (docstrings), context-sensitive completion, @kbd{M-.} to jump to an object definition, a REPL to try out your code, and more (@pxref{Introduction,,, geiser, Geiser User Manual}).  If you allow Emacs to load the @file{.dir-locals.el} file at the root of the project checkout, it will cause Geiser to automatically add the local Guix sources to the Guile load path."
msgstr "Geiser 允许在 Emacs 里进行交互增量式的开发：buffer 里的代码编译和执行，即时文档 获取 (docstrings)，根据上下文补全，@kbd{M-.} 跳转到对象定义，用来尝试代码的 REPL，及更多（@pxref{Introduction,,, geiser, Geiser User Manual}）。如果你允许 Emacs 在项目根目录加载@file{.dir-locals.el}中的文件，Geiser 将会自动将项目根目录下的 guix 资源添加到 Guile 加载路径中。"

msgid "To actually edit the code, Emacs already has a neat Scheme mode.  But in addition to that, you must not miss @url{https://www.emacswiki.org/emacs/ParEdit, Paredit}.  It provides facilities to directly operate on the syntax tree, such as raising an s-expression or wrapping it, swallowing or rejecting the following s-expression, etc."
msgstr "真正编辑代码时别忘了 Emacs 自带了方便的 Scheme 模式。而且，一定不要错过 @url{https://www.emacswiki.org/emacs/ParEdit, Paredit}。它提供了直接操作语法树的的功能，例如，用 S- 表达式替换父节点，为 S- 表达式添加、删除前后的括号，删除后面的 S- 表达式，等等。"

msgid "code snippets"
msgstr "代码片段"

msgid "templates"
msgstr "模板"

msgid "reducing boilerplate"
msgstr "减少样板"

msgid ""
";; @r{Assuming the Guix checkout is in ~/src/guix.}\n"
";; @r{Yasnippet configuration}\n"
"(with-eval-after-load 'yasnippet\n"
"  (add-to-list 'yas-snippet-dirs \"~/src/guix/etc/snippets/yas\"))\n"
";; @r{Tempel configuration}\n"
"(with-eval-after-load 'tempel\n"
"   ;; Ensure tempel-path is a list -- it may also be a string.\n"
"   (unless (listp 'tempel-path)\n"
"     (setq tempel-path (list tempel-path)))\n"
"   (add-to-list 'tempel-path \"~/src/guix/etc/snippets/tempel/*\"))\n"
msgstr ""
";; @r{假设 Guix 签出在 ~/src/guix 中。}\n"
";; @r{Yasnippet 配置}\n"
"(with-eval-after-load 'yasnippet\n"
"  (add-to-list 'yas-snippet-dirs \"~/src/guix/etc/snippets/yas\"))\n"
";; @r{Tempel 配置}\n"
"(with-eval-after-load 'tempel\n"
"   ;; 确保 tempel-path 是一个列表——它也可以是一个字符串。\n"
"   (unless (listp 'tempel-path)\n"
"     (setq tempel-path (list tempel-path)))\n"
"   (add-to-list 'tempel-path \"~/src/guix/etc/snippets/tempel/*\"))\n"

msgid "The commit message snippets depend on @url{https://magit.vc/, Magit} to display staged files.  When editing a commit message type @code{add} followed by @kbd{TAB} to insert a commit message template for adding a package; type @code{update} followed by @kbd{TAB} to insert a template for updating a package; type @code{https} followed by @kbd{TAB} to insert a template for changing the home page URI of a package to HTTPS."
msgstr "commit 信息片段显示 staged 文件需要依赖@url{https://magit.vc/, Magit}。编辑commit 信息时，输入@code{add}，然后按@kbd{TAB}就可以插入一段用于新增软件包的模板；输入@code{update}，然后按@kbd{TAB}可以插入一段更新软件包的模板；输入@code{https}然后按@kbd{TAB}可以插入一段修改主页 URI 为 HTTPS 的模板。"

msgid "The main snippet for @code{scheme-mode} is triggered by typing @code{package...} followed by @kbd{TAB}.  This snippet also inserts the trigger string @code{origin...}, which can be expanded further.  The @code{origin} snippet in turn may insert other trigger strings ending on @code{...}, which also can be expanded further."
msgstr "@code{scheme-mode}最重要的模板可以通过输入@code{package...}，然后按@kbd{TAB}触发。这个片段还插入了触发字符串@code{origin...}，以进一步展开。@code{origin}片段更进一步的可能插入其它以@code{...}结尾的触发字符串，它们可以被继续展开。"

msgid "insert or update copyright"
msgstr "插入或更新版权"

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

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

msgid "We additionally provide insertion and automatic update of a copyright in @file{etc/copyright.el}.  You may want to set your full name, mail, and load a file."
msgstr "我们在@file{etc/copyright.el} 中额外提供了版权的插入和自动更新。你也许会想要设置你的全名，邮箱以及加载一个文件。"

msgid ""
"(setq user-full-name \"Alice Doe\")\n"
"(setq user-mail-address \"alice@@mail.org\")\n"
";; @r{Assuming the Guix checkout is in ~/src/guix.}\n"
"(load-file \"~/src/guix/etc/copyright.el\")\n"
msgstr ""
"(setq user-full-name \"Alice Doe\")\n"
"(setq user-mail-address \"alice@@mail.org\")\n"
";; @r{假设 Guix 签出在 ~/src/guix。}\n"
"(load-file \"~/src/guix/etc/copyright.el\")\n"

msgid "To insert a copyright at the current line invoke @code{M-x guix-copyright}."
msgstr "要在当前行插入版权信息，调用@code{M-x guix-copyright}。"

msgid "To update a copyright you need to specify a @code{copyright-names-regexp}."
msgstr "要更新一个版权信息，你需要指定 @code{copyright-names-regexp}。"

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

msgid "You can check if your copyright is up to date by evaluating @code{M-x copyright-update}.  If you want to do it automatically after each buffer save then add @code{(add-hook 'after-save-hook 'copyright-update)} in Emacs."
msgstr "你可以通过执行 @code{M-x copyright-update} 检查版权信息是否已更新。若你想要在每次缓存区保存后自动做这件事，就在 Emacs 中添加 @code{(add-hook 'after-save-hook 'copyright-update)}."

msgid "Guile Studio is a pre-configured Emacs with mostly everything you need to start hacking in Guile. If you are not familiar with Emacs it makes the transition easier for you."
msgstr "Guile Studio 是预配置的 Emacs 环境，已集成 Guile 开发所需的主要组件。即便您不熟悉 Emacs，亦可助您轻松过渡开发实践。"

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

msgid "Guile Studio comes with Geiser preinstalled and prepared for action."
msgstr "Guile Studio 预装了 Geiser，可随时使用。"

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

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

msgid "We also recommend that you run @code{:set autoindent} so that your code is automatically indented as you type."
msgstr "建议运行 @code{:set autoindent}，以便在输入代码时自动缩进。"

msgid "For the interaction with Git, @uref{https://www.vim.org/scripts/script.php?script_id=2975, @code{fugitive.vim}} is the most commonly used plugin:"
msgstr "@uref{https://www.vim.org/scripts/script.php?script_id=2975, @code{fugitive.vim}} 是最常用的 Git 交互插件："

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

msgid "And of course if you want to interact with Guix directly from inside of vim, using the built-in terminal emulator, we have our very own @code{guix.vim} package!"
msgstr "当然，如果你想直接在 vim 中使用内置终端模拟器与 Guix 交互，我们还有自己的 @code{guix.vim} 软件包！"

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

msgid "In NeoVim you can even make a similar setup to Geiser using @url{https://conjure.fun/, Conjure} that lets you connect to a running Guile process and inject your code there live (sadly it's not packaged in Guix yet)."
msgstr "在 NeoVim 中，你甚至可以使用 @url{https://conjure.fun/, Conjure} 进行与 Geiser 类似的配置，从而连接到正在运行的 Guile 进程，并在其中实时注入代码（遗憾的是 Guix 还没有打包）。"

msgid "structure, of the source tree"
msgstr "源代码树的结构"

msgid "If you're willing to contribute to Guix beyond packages, or if you'd like to learn how it all fits together, this section provides a guided tour in the code base that you may find useful."
msgstr "如果您愿意在 Guix 中贡献超出软件包范畴的内容，或者如果您想了解它是如何结合在一起的，本节提供了代码库的导览，或许对您有用。"

msgid "Overall, the Guix source tree contains almost exclusively Guile @dfn{modules}, each of which can be seen as an independent library (@pxref{Modules,,, guile, GNU Guile Reference Manual})."
msgstr "总体而言，Guix 源树几乎只包含 Guile @dfn{模块}，每个模块都可以视为一个独立的库（@pxref{Modules,,, guile, GNU Guile Reference Manual}）。"

msgid "guix"
msgstr "guix"

msgid "This is the location of core Guix mechanisms.  To illustrate what is meant by ``core'', here are a few examples, starting from low-level tools and going towards higher-level tools:"
msgstr "这是 Guix 核心机理的存放位置。这里有几个例子说明“核心”是什么意思，从底层工具到高层工具："

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

msgid "Connecting to and interacting with the build daemon (@pxref{The Store})."
msgstr "连接并与负责构建的守护进程交互（@pxref{The Store}）。"

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

msgid "Creating derivations (@pxref{Derivations})."
msgstr "创建衍生物（@pxref{Derivations}）。"

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

msgid "Writing G-expressions (@pxref{G-Expressions})."
msgstr "编写 G-表达式 (@pxref{G-Expressions})."

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

msgid "Defining packages and origins (@pxref{package Reference})."
msgstr "定义软件包及来源 (@pxref{package Reference})."

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

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

msgid "The @code{url-fetch} and @code{git-fetch} origin download methods (@pxref{origin Reference})."
msgstr "@code{url-fetch} 和 @code{git-fetch} 来源的下载方法 (@pxref{origin Reference})."

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

msgid "Fetching source code from the @uref{https://archive.softwareheritage.org,Software Heritage archive}."
msgstr "从 @uref{https://archive.softwareheritage.org,Software Heritage archive} 拿取源代码。"

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

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

msgid "The build system interface (@pxref{Build Systems})."
msgstr "负责构建的系统的接口 (@pxref{Build Systems})。"

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

msgid "Implementing profiles."
msgstr "实现 profiles。"

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

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

msgid "the GNU build system;"
msgstr "GNU 构建系统"

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

msgid "the CMake build system;"
msgstr "CMake 构建系统；"

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

msgid "The Python ``pyproject'' build system."
msgstr "Python 的“pyproject”构建系统。"

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

msgid "This contains code generally used on the ``build side'' (@pxref{G-Expressions, strata of code}).  This includes code used to build packages or other operating system components, as well as utilities:"
msgstr "这包含通常在“构建端”使用的代码 (@pxref{G-Expressions, strata of code}).  这包括用于构建包或其他操作系统组件的代码，以及其他一些工具："

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

msgid "Utilities for package definitions and more (@pxref{Build Utilities})."
msgstr "关于软件包定义的工具和更多（@pxref{Build Utilities}）。"

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

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

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

msgid "Implementation of build systems, and in particular definition of their build phases (@pxref{Build Phases})."
msgstr "构建系统的实现，具体来说是定义其构建阶段@pxref{Build Phases}（@pxref{Build Phases})."

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

msgid "Interface to the C library and to Linux system calls."
msgstr "到 C 库和 Linux 系统调用的接口。"

msgid "command-line tools, as Guile modules"
msgstr "作为 Guile 模块的命令行工具"

msgid "command modules"
msgstr "命令模块"

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

msgid "This contains modules corresponding to @command{guix} sub-commands.  For example, the @code{(guix scripts shell)} module exports the @code{guix-shell} procedure, which directly corresponds to the @command{guix shell} command (@pxref{Invoking guix shell})."
msgstr "这包括了相应于 @command{guix} 子命令的模块。例如，@code{(guix scripts shell)} 模块导出了 @code{guix-shell} 过程，这直接对应于 @command{guix shell} 命令（@pxref{Invoking guix shell}）。"

msgid "importer modules"
msgstr "导入器模块"

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

msgid "This contains supporting code for the importers and updaters (@pxref{Invoking guix import}, and @pxref{Invoking guix refresh}).  For example, @code{(guix import pypi)} defines the interface to PyPI, which is used by the @command{guix import pypi} command."
msgstr "这包含了对于导入器和升级器的支持代码（@pxref{Invoking guix import}，以及 @pxref{Invoking guix refresh}）。例如，@code{(guix import pypi)} 定义了 PyPI 的接口，这由 @command{guix import pypi} 命令使用。"

msgid "The directories we have seen so far all live under @file{guix/}.  The other important place is the @file{gnu/} directory, which contains primarily package definitions as well as libraries and tools for Guix System (@pxref{System Configuration}) and Guix Home (@pxref{Home Configuration}), all of which build upon functionality provided by @code{(guix @dots{})} modules@footnote{For this reason, @code{(guix @dots{})} modules must generally not depend on @code{(gnu @dots{})} modules, with notable exceptions: @code{(guix build-system @dots{})} modules may look up packages at run time---e.g., @code{(guix build-system cmake)} needs to access the @code{cmake} variable at run time---, @code{(guix scripts @dots{})} often rely on @code{(gnu @dots{})} modules, and the same goes for some of the @code{(guix import @dots{})} modules.}."
msgstr "到目前为止我们看到的所有文件夹都位于 @file{guix/} 下。另一个重要的地方是 @file{gnu/} 目录，它主要包含包定义以及 Guix 系统 (@pxref{System Configuration}) 和 Guix Home (@pxref{Home Configuration}) 的库和工具，所有这些都建立在 @code{(guix @dots{})} 模块提供的功能之上@footnote{因此，@code{(guix @dots{})} 模块通常不应依赖于 @code{(gnu @dots{})} 模块，尽管有一些显著的例外：@code{(guix build-system @dots{})} 模块可以在运行时查找包——例如，@code{(guix build-system cmake)} 需要在运行时访问 @code{cmake} 变量——，@code{(guix scripts @dots{})} 通常依赖于 @code{(gnu @dots{})} 模块，@code{(guix import @dots{})} 模块中的某些模块也是如此。}。"

msgid "package modules"
msgstr "软件包模块"

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

msgid "This is by far the most crowded directory of the source tree: it contains @dfn{package modules} that export package definitions (@pxref{Package Modules}).  A few examples:"
msgstr "这是源代码树中最拥挤的文件夹：它包含导出包定义（@pxref{Package Modules}）的 @dfn{包模块}。举几个例 子："

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

msgid "Module providing ``base'' packages: @code{glibc}, @code{coreutils}, @code{grep}, etc."
msgstr "提供“基础”包的模块：@code{glibc}, @code{coreutils}, @code{grep}, 等等。"

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

msgid "Guile and core Guile packages."
msgstr "Guile 和核心 Guile 包。"

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

msgid "The Linux-libre kernel and related packages."
msgstr "Linux-libre 内核及相关软件包。"

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

msgid "Python and core Python packages."
msgstr "Python 和核心 Python 软件包。"

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

msgid "Miscellaneous Python packages (we were not very creative)."
msgstr "杂项 Python 软件包（不是开玩笑）。"

msgid "In any case, you can jump to a package definition using @command{guix edit} (@pxref{Invoking guix edit}) and view its location with @command{guix show} (@pxref{Invoking guix package})."
msgstr "无论何时，您都可以使用@command{guix edit}跳转到软件包定义（@pxref{Invoking guix edit}），并使用@command{guix show}查看其位置（@pxref{Invoking guix package})."

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

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

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

msgid "This contains service definitions, primarily for Guix System (@pxref{Services}) but some of them are adapted and reused for Guix Home as we will see below.  Examples:"
msgstr "这包含服务的定义，主要用于 Guix 系统（@pxref{Services}），但其中一些被调整并重用于 Guix Home，如下所示。示例："

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

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

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

msgid "``Desktop'' services (@pxref{Desktop Services})."
msgstr "桌面服务（@pxref{Desktop Services}）。"

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

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

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

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

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

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

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

msgid "Activating an operating system at boot time or reconfiguration time."
msgstr "在启动或者重新配置（reconfigure）时激活一个操作系统。"

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

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

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

msgid "Booting GNU/Linux and GNU/Hurd operating systems."
msgstr "启动 GNU/Linux 和 GNU/Hurd 操作系统。"

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

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

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

msgid "Core services such as @code{home-files-service-type}."
msgstr "诸如@code{home-files-service-type}的核心服务。"

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

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

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

msgid "These are the @dfn{machine abstractions} used by @command{guix deploy} (@pxref{Invoking guix deploy})."
msgstr "这些是被@command{guix deploy}使用到@dfn{机器抽象}（@pxref{Invoking guix deploy})."

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

msgid "nix"
msgstr "nix"

msgid "tests"
msgstr "tests"

msgid "doc"
msgstr "doc"

msgid "po"
msgstr "po"

msgid "etc"
msgstr "etc"

msgid "packages, creating"
msgstr "软件包，创建"

msgid "The GNU distribution is nascent and may well lack some of your favorite packages.  This section describes how you can help make the distribution grow."
msgstr "这个 GNU 发行版正在开发的早期阶段，可能缺少一些你喜欢的软件。这个章节介绍你可以怎样帮助这个发行版成长。"

msgid "Free software packages are usually distributed in the form of @dfn{source code tarballs}---typically @file{tar.gz} files that contain all the source files.  Adding a package to the distribution means essentially two things: adding a @dfn{recipe} that describes how to build the package, including a list of other packages required to build it, and adding @dfn{package metadata} along with that recipe, such as a description and licensing information."
msgstr "自由软件通常以@dfn{源代码包}的形式分发，通常是包含完整代码的@file{tar.gz}包。添加软件包到这个发行版意味着两件事：添加描述如何构建包的@dfn{配方}和一系列依赖软件，以及添加配方之外的@dfn{软件包元数据}，如一段文字描述和证书信息。"

msgid "In Guix all this information is embodied in @dfn{package definitions}.  Package definitions provide a high-level view of the package.  They are written using the syntax of the Scheme programming language; in fact, for each package we define a variable bound to the package definition, and export that variable from a module (@pxref{Package Modules}).  However, in-depth Scheme knowledge is @emph{not} a prerequisite for creating packages.  For more information on package definitions, @pxref{Defining Packages}."
msgstr "在 Guix 里所有这些信息都包含在@dfn{软件包定义}里。软件包定义提供了软件包的高层视角。它们使用 Scheme 编程语言编写，事实上，对每个软件包我们都定义一个绑定到软件包定义的的变量，并且从模块（@pxref{Package Modules}）中导出那个变量。然而，深入的 Scheme 知识@emph{不}是创建软件包的前提条件。若要了解软件包的更多信息，@pxref{Defining Packages}."

msgid "Once a package definition is in place, stored in a file in the Guix source tree, it can be tested using the @command{guix build} command (@pxref{Invoking guix build}).  For example, assuming the new package is called @code{gnew}, you may run this command from the Guix build tree (@pxref{Running Guix Before It Is Installed}):"
msgstr "一旦软件包定义准备好了，并且包存在 Guix 代码树的一个文件里，你可以用@command{guix build} (@pxref{Invoking guix build}) 命令测试它。假设这个新软件包的名字叫做@code{gnew}，你可以在 Guix 构建树里运行这个命令 (@pxref{Running Guix Before It Is Installed}):"

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

msgid "Using @code{--keep-failed} makes it easier to debug build failures since it provides access to the failed build tree.  Another useful command-line option when debugging is @code{--log-file}, to access the build log."
msgstr "使用@code{--keep-failed}参数会保留失败的构建树，这可以使调试构建错误更容易。@code{--log-file}也是一个调试时很有用的参数，它可以用来访问构建日志。"

msgid "If the package is unknown to the @command{guix} command, it may be that the source file contains a syntax error, or lacks a @code{define-public} clause to export the package variable.  To figure it out, you may load the module from Guile to get more information about the actual error:"
msgstr "如果@command{guix}命令找不到这个软件包，那可能是因为源文件包含语法错误，或者缺少导出软件包的@code{define-public}语句。为了查找错误，你可以用 Guile 导入这个模块以了解这个错误的详情："

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

msgid "Once your package builds correctly, please send us a patch (@pxref{Submitting Patches}).  Well, if you need help, we will be happy to help you too.  Once the patch is committed in the Guix repository, the new package automatically gets built on the supported platforms by @url{https://@value{SUBSTITUTE-SERVER-1}, our continuous integration system}."
msgstr "一旦你的软件包可以正确构建，请给我们发送补丁 (@pxref{Submitting Patches})。当然，如果你需要帮助，我们也会很乐意帮助你。一旦补丁被提交到 Guix 仓库里，这个新的软件包会由@url{https://@value{SUBSTITUTE-SERVER-1}, our continuous integration system}自动地在支持的平台上构建。"

msgid "substituter"
msgstr "substitutes"

msgid "Software Freedom"
msgstr "软件自由"

msgid "What may go into the distribution."
msgstr "什么可以进入这个发行版。"

msgid "Package Naming"
msgstr "软件包命名"

msgid "What's in a name?"
msgstr "名字里包含什么？"

msgid "Version Numbers"
msgstr "版本号"

msgid "When the name is not enough."
msgstr "当名字不够时。"

msgid "Synopses and Descriptions"
msgstr "简介和描述"

msgid "Helping users find the right package."
msgstr "帮助用户寻找合适的软件包。"

msgid "Snippets versus Phases"
msgstr "原始片段 vs. 构建阶段"

msgid "Whether to use a snippet, or a build phase."
msgstr "用片段，还是用构建阶段。"

msgid "Cyclic Module Dependencies"
msgstr "模块的循环依赖"

msgid "Emacs Packages"
msgstr "Emacs 包"

msgid "Your Elisp fix."
msgstr "你的 Elisp 补丁。"

msgid "Python Modules"
msgstr "Python 模块"

msgid "A touch of British comedy."
msgstr "一点英式喜剧。"

msgid "Perl Modules"
msgstr "Perl 模块"

msgid "Little pearls."
msgstr "小珍珠。"

msgid "Java Packages"
msgstr "Java 包"

msgid "Coffee break."
msgstr "喝咖啡休息。"

msgid "Rust Crates"
msgstr "Rust Crates"

msgid "Beware of oxidation."
msgstr "谨防氧化。"

msgid "Elm Packages"
msgstr "Elm 包"

msgid "Trees of browser code"
msgstr "树状浏览器代码"

msgid "Fonts"
msgstr "字体"

msgid "Fond of fonts."
msgstr "字体的乐趣。"

msgid "free software"
msgstr "自由软件"

msgid "The GNU operating system has been developed so that users can have freedom in their computing.  GNU is @dfn{free software}, meaning that users have the @url{https://www.gnu.org/philosophy/free-sw.html,four essential freedoms}: to run the program, to study and change the program in source code form, to redistribute exact copies, and to distribute modified versions.  Packages found in the GNU distribution provide only software that conveys these four freedoms."
msgstr "开发 GNU 操作系统是为了用户拥有计算的自由。GNU 是@dfn{自由软件}，这意味着它有@url{https://www.gnu.org/philosophy/free-sw.html，四项重要的自由}：运行程序的自由，以源代码形式学习和修改程序的自由，原样重新分发副本的自由，和分发修改后的版本的自由。GNU 发行版里包含的软件包只提供遵守这四项自由的软件。"

msgid "In addition, the GNU distribution follow the @url{https://www.gnu.org/distros/free-system-distribution-guidelines.html,free software distribution guidelines}.  Among other things, these guidelines reject non-free firmware, recommendations of non-free software, and discuss ways to deal with trademarks and patents."
msgstr "此外，GNU 发行版遵循@url{https://www.gnu.org/distros/free-system-distribution-guidelines.html，自由软件发行版准则}。这些准则拒绝非自由的固件和对非自由软件的推荐，并讨论解决商标和专利的方法。"

msgid "Some otherwise free upstream package sources contain a small and optional subset that violates the above guidelines, for instance because this subset is itself non-free code.  When that happens, the offending items are removed with appropriate patches or code snippets in the @code{origin} form of the package (@pxref{Defining Packages}).  This way, @code{guix build --source} returns the ``freed'' source rather than the unmodified upstream source."
msgstr "某些上游的软件包源代码包含一小部分违反上述准则的可选的子集，比如这个子集本身就是非自由代码。这时，这些讨厌的代码需要用合适的补丁或者软件包定义（@pxref{Defining Packages}）里的@code{origin}里的代码片段移除。这样，@code{guix build --source}就可以返回自由的源代码而不是未经修改的上游源代码。"

msgid "package name"
msgstr "软件包名字"

msgid "A package actually has two names associated with it.  First, there is the name of the @emph{Scheme variable}, the one following @code{define-public}.  By this name, the package can be made known in the Scheme code, for instance as input to another package.  Second, there is the string in the @code{name} field of a package definition.  This name is used by package management commands such as @command{guix package} and @command{guix build}."
msgstr "一个软件包事实上有两个名字：第一个是@emph{Scheme 变量}的名字，即用@code{define-public}定义的名字。通过这个名字，软件包可以被 Scheme 代码找到，如用作其它软件包的输入。第二个名字是软件包定义里的@code{name}属性的字符串值。这个名字用于软件包管理命令，如：@command{guix package}，@command{guix build}。"

msgid "Both are usually the same and correspond to the lowercase conversion of the project name chosen upstream, with underscores replaced with hyphens.  For instance, GNUnet is available as @code{gnunet}, and SDL_net as @code{sdl-net}."
msgstr "两个名字通常是相同的，常是上游项目名字转成小写字母并把下划线替换成连字符的结果。比如，GNUnet 转成@code{gnunet}，SDL_net 转成@code{sdl-net}。"

msgid "A noteworthy exception to this rule is when the project name is only a single character, or if an older maintained project with the same name already exists---regardless of whether it has already been packaged for Guix.  Use common sense to make such names unambiguous and meaningful.  For example, Guix's package for the shell called ``s'' upstream is @code{s-shell} and @emph{not} @code{s}.  Feel free to ask your fellow hackers for inspiration."
msgstr "这条规则有一个值得注意的例外，那就是当工程名只有一个字符，或与它同名的一个旧工程已经存在——不论是否已经被打为 Guix 包。你应该动用常识来让这些名字无歧义且有意义。比如说，上游称为 ``s'' 的 shell 程序在 Guix 中称为 @code{s-shell} 而 @emph{不是} @code{s}。你可以随便问问你的黑客伙计们来获得一些启发。"

msgid "We do not add @code{lib} prefixes for library packages, unless these are already part of the official project name.  But @pxref{Python Modules} and @ref{Perl Modules} for special rules concerning modules for the Python and Perl languages."
msgstr "我们不给库软件包添加@code{lib}前缀，除非它是项目官方名字的一部分。但是@pxref{Python Modules}和@ref{Perl Modules}有关于 Python 和 Perl 语言的特殊规则。"

msgid "Font package names are handled differently, @pxref{Fonts}."
msgstr "字体软件包的名字处理起来不同，@pxref{Fonts}."

msgid "package version"
msgstr "软件包版本"

msgid "We usually package only the latest version of a given free software project.  But sometimes, for instance for incompatible library versions, two (or more) versions of the same package are needed.  These require different Scheme variable names.  We use the name as defined in @ref{Package Naming} for the most recent version; previous versions use the same name, suffixed by @code{-} and the smallest prefix of the version number that may distinguish the two versions."
msgstr "我们通常只为每个自由软件的最新版本打包。但是有时候，比如对于版本不兼容的库，需要有同一个软件包的两个或更多版本。它们需要使用不同的 Scheme 变量名。我们为最新的版本使用@ref{Package Naming}里规定的名字，旧的版本使用加上后缀的名字，后缀是@code{-}和可以区分开版本号的版本号的最小前缀。"

msgid "The name inside the package definition is the same for all versions of a package and does not contain any version number."
msgstr "软件包定义里的名字对于同一个软件包的所有版本都是相同的，并且不含有版本号。"

msgid "For instance, the versions 2.24.20 and 3.9.12 of GTK+ may be packaged as follows:"
msgstr "例如，GTK+ 的 2.24.20 和 3.9.12 两个版本可以这样打包："

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

msgid "If we also wanted GTK+ 3.8.2, this would be packaged as"
msgstr "如果我们还需要 GTK+ 3.8.2，就这样打包"

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

msgid "version number, for VCS snapshots"
msgstr "用于版本控制快照的版本号"

msgid "Occasionally, we package snapshots of upstream's version control system (VCS) instead of formal releases.  This should remain exceptional, because it is up to upstream developers to clarify what the stable release is.  Yet, it is sometimes necessary.  So, what should we put in the @code{version} field?"
msgstr "有时候，我们为软件包上游的版本控制系统（VCS）的快照而不是正式发布版打包。这是特殊情况，因为决定哪个是稳定版的权力应该属于上游开发者。然而，有时候这是必须的。那么，我们该如何决定写在@code{version}里的版本号呢？"

msgid "Clearly, we need to make the commit identifier of the VCS snapshot visible in the version string, but we also need to make sure that the version string is monotonically increasing so that @command{guix package --upgrade} can determine which version is newer.  Since commit identifiers, notably with Git, are not monotonically increasing, we add a revision number that we increase each time we upgrade to a newer snapshot.  The resulting version string looks like this:"
msgstr "显然，我们需要让 VCS 快照的 commit ID 在版本号中体现出来，但是我们也需要确保版本号单调递增，以便@command{guix package --upgrade}决定哪个版本号更新。由于commit ID，尤其是 Git 的 commit ID，不是单调递增的，我们添加一个每次升级快照时都手动增长的 revision 数字。最后的版本号字符串看起来是这样："

msgid ""
"2.0.11-3.cabba9e\n"
"  ^    ^    ^\n"
"  |    |    `-- upstream commit ID\n"
"  |    |\n"
"  |    `--- Guix package revision\n"
"  |\n"
"latest upstream version\n"
msgstr ""
"2.0.11-3.cabba9e\n"
"  ^    ^    ^\n"
"  |    |    `-- 上游的 commit ID\n"
"  |    |\n"
"  |    `--- Guix 软件包的 revision\n"
"  |\n"
"最新的上游版本号\n"

msgid "It is a good idea to strip commit identifiers in the @code{version} field to, say, 7 digits.  It avoids an aesthetic annoyance (assuming aesthetics have a role to play here) as well as problems related to OS limits such as the maximum shebang length (127 bytes for the Linux kernel).  There are helper functions for doing this for packages using @code{git-fetch} or @code{hg-fetch} (see below).  It is best to use the full commit identifiers in @code{origin}s, though, to avoid ambiguities.  A typical package definition may look like this:"
msgstr "把@code{版本号}里的 commit ID 截短，比如只取 7 个数字，是一个好主意。它避免了美学上的烦恼（假设美学在这里很重要），以及操作系统限制引起的问题（比如 Linux 内核的127 字节）。尽管如此，在@code{origin}里最好使用完整的 commit ID，以避免混淆。通常一个软件包应该看起来是下面这样："

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

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

msgid "Return the version string for packages using @code{git-fetch}."
msgstr "返回包的版本字符串，利用 @code{git-fetch}。"

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

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

msgid "Return the version string for packages using @code{hg-fetch}.  It works in the same way as @code{git-version}."
msgstr "返回包的版本字符串，利用  @code{hg-fetch}，就像 @code{git-version} 那样。"

msgid "package description"
msgstr "软件包描述"

msgid "package synopsis"
msgstr "软件包简介"

msgid "As we have seen before, each package in GNU@tie{}Guix includes a synopsis and a description (@pxref{Defining Packages}).  Synopses and descriptions are important: They are what @command{guix package --search} searches, and a crucial piece of information to help users determine whether a given package suits their needs.  Consequently, packagers should pay attention to what goes into them."
msgstr "我们已经看到，GNU@tie{}Guix 里的每个软件包都包含一个简介（synopsis）和一个描述（description）（@pxref{Defining Packages}）。简介和描述很重要：它们是@command{guix package --search}搜索的信息，并且是帮助用户决定一个软件包是否符合自己需求的重要信息。因此，打包的人应该关注怎样写它们的内容。"

msgid "Synopses must start with a capital letter and must not end with a period.  They must not start with ``a'' or ``the'', which usually does not bring anything; for instance, prefer ``File-frobbing tool'' over ``A tool that frobs files''.  The synopsis should say what the package is---e.g., ``Core GNU utilities (file, text, shell)''---or what it is used for---e.g., the synopsis for GNU@tie{}grep is ``Print lines matching a pattern''."
msgstr "简介必须以大写字母开头，并且不能以句号结尾。它们不能以 ``a'' 或者 ``the'' 等没有意义的词开头。例如 ``File-frobbing tool'' 要比 ``A tool that frobs files'' 更好。简介需要说明软件包是什么－－如 ``Core GNU utilities (file, text, shell)''，或者它的用途－－如 GNU@tie{}grep 的简介是 ``Print lines matching a pattern''."

msgid "Keep in mind that the synopsis must be meaningful for a very wide audience.  For example, ``Manipulate alignments in the SAM format'' might make sense for a seasoned bioinformatics researcher, but might be fairly unhelpful or even misleading to a non-specialized audience.  It is a good idea to come up with a synopsis that gives an idea of the application domain of the package.  In this example, this might give something like ``Manipulate nucleotide sequence alignments'', which hopefully gives the user a better idea of whether this is what they are looking for."
msgstr "记住，简介必须能被广大的听众理解。例如，“以 SAM 格式修改对齐”可能对经验丰富的生物信息科研工作者来说能理解，但是对普通对听众则是无用的甚至是令人误解的。简介最好说明软件包应用的领域。在这个例子中，应该这样描述“修改核苷酸序列的对齐格式”，这会让用户更容易判断这是不是他们想要的。"

msgid "Descriptions should take between five and ten lines.  Use full sentences, and avoid using acronyms without first introducing them.  Please avoid marketing phrases such as ``world-leading'', ``industrial-strength'', and ``next-generation'', and avoid superlatives like ``the most advanced''---they are not helpful to users looking for a package and may even sound suspicious.  Instead, try to be factual, mentioning use cases and features."
msgstr "描述应该在 5 至 10 句话之间。使用完整的句子，并且避免在未介绍的情况下使用缩写。请避免推广营销性对词汇，如“世界领先”，“行业最强”，“下一代”，并且避免高级的形容词，如“最先进的”--他们对用户寻找软件包是无用的，甚至是可疑的。相反的，尽量务实，提及用例和功能。"

msgid "Texinfo markup, in package descriptions"
msgstr "软件包描述里的 Texinfo 标记"

msgid "Synopses and descriptions are translated by volunteers @uref{https://translate.codeberg.org/projects/guix/packages, at Weblate} so that as many users as possible can read them in their native language.  User interfaces search them and display them in the language specified by the current locale."
msgstr "简介和描述@uref{https://translate.codeberg.org/projects/guix/packages, 由 Weblate}项目的志愿者翻译，从而使尽可能多的用户可以用母语阅读。用户界面用当前区域设置的语言搜索和展示这些信息。"

msgid "To allow @command{xgettext} to extract them as translatable strings, synopses and descriptions @emph{must be literal strings}.  This means that you cannot use @code{string-append} or @code{format} to construct these strings:"
msgstr "为了让@command{xgettext}可以把它们提取成待翻译的字符串，简介和描述@emph{必须是文字字符串}。这意味着你不能使用@code{string-append}或@code{format}来合成字符串："

msgid ""
"(package\n"
"  ;; @dots{}\n"
"  (synopsis \"This is translatable\")\n"
"  (description (string-append \"This is \" \"*not*\" \" translatable.\")))\n"
msgstr ""
"(package\n"
"  ;; @dots{}\n"
"  (synopsis \"这是可以翻译的\")\n"
"  (description (string-append \"这是\" \"*不可以*\" \"翻译的\")))\n"

msgid "Translation is a lot of work so, as a packager, please pay even more attention to your synopses and descriptions as every change may entail additional work for translators.  In order to help them, it is possible to make recommendations or instructions visible to them by inserting special comments like this (@pxref{xgettext Invocation,,, gettext, GNU Gettext}):"
msgstr "翻译是很繁重的工作，所以，作为打包者请更加注意你的简介和介绍，每一个改动都会增加翻译的工作量。为了帮助他们，你可以插入这类可以被他们看到的建议和指示(@pxref{xgettext Invocation,,, gettext, GNU Gettext}):"

msgid ""
";; TRANSLATORS: \"X11 resize-and-rotate\" should not be translated.\n"
"(description \"ARandR is designed to provide a simple visual front end\n"
"for the X11 resize-and-rotate (RandR) extension. @dots{}\")\n"
msgstr ""
";; TRANSLATORS: \"X11 resize-and-rotate\"不需要翻译。\n"
"(description \"ARandR 为 X11 resize-and-rotate (RandR) 扩展提供简单的图形界面。@dots{}\")\n"

msgid "snippets, when to use"
msgstr "何时使用片段"

msgid "The boundary between using an origin snippet versus a build phase to modify the sources of a package can be elusive.  Origin snippets are typically used to remove unwanted files such as bundled libraries, nonfree sources, or to apply simple substitutions.  The source derived from an origin should produce a source that can be used to build the package on any system that the upstream package supports (i.e., act as the corresponding source).  In particular, origin snippets must not embed store items in the sources; such patching should rather be done using build phases.  Refer to the @code{origin} record documentation for more information (@pxref{origin Reference})."
msgstr "原始片段和构建阶段的边界比较难以理解。原始片段通常用来移除不想要的文件，比如捆绑的库，非自由源，或者用于应用简单的替换。从原始源迭代出的源应该在上游包支持的系统上都能成功构建包（就是说，像对应的原始源那样动作）。尤其是，原始片段一定不能内嵌有 store 中的项目；这样的补丁更应该在构建阶段完成。参考@code{origin} 记录文档获取更多信息（@pxref{origin Reference}）。"

msgid "Here is a common trap to avoid:"
msgstr "这是一个需要避免的常见问题："

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

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

msgid "emacs, packaging"
msgstr "emacs，打包"

msgid "elisp, packaging"
msgstr "elisp，打包"

msgid "Emacs packages should preferably use the Emacs build system (@pxref{emacs-build-system}), for uniformity and the benefits provided by its build phases, such as the auto-generation of the autoloads file and the byte compilation of the sources.  Because there is no standardized way to run a test suite for Emacs packages, tests are disabled by default.  When a test suite is available, it should be enabled by setting the @code{#:tests?} argument to @code{#true}.  By default, the command to run the test is @command{make check}, but any command can be specified via the @code{#:test-command} argument.  The @code{#:test-command} argument expects a list containing a command and its arguments, to be invoked during the @code{check} phase."
msgstr "为统一化以及享受构建阶段的方便，比如自动生成 autoloads 文件、字节编译源文件，Emacs 包应该选择 Emacs 构建系统（@pxref{emacs-build-system}）。由于没有标准化的方法运行 Emacs 包的测试用例，测试默认是禁用的。当一个测试用例可用时，可以通过设置 @code{#:tests?} 参数为 @code{#true} 启用。默认条件下，运行测试的命令是 @command{make check}，不过其它的命令也可以用 @code{#:test-command} 参数指定。参数 @code{#:test-command} 应当由包含命令和命令参数的列表，并在 @code{check} 阶段调用。"

msgid "The Elisp dependencies of Emacs packages are typically provided as @code{propagated-inputs} when required at run time.  As for other packages, build or test dependencies should be specified as @code{native-inputs}."
msgstr "Emacs 包的 Elisp 依赖项通常在运行时需要时作为 @code{propagated-inputs} 提供。对于其他包，构建或测试依赖项应指定为@code{native-inputs}。"

msgid "Emacs packages sometimes depend on resources directories that should be installed along the Elisp files.  The @code{#:include} argument can be used for that purpose, by specifying a list of regexps to match.  The best practice when using the @code{#:include} argument is to extend rather than override its default value (accessible via the @code{%default-include} variable).  As an example, a yasnippet extension package typically include a @file{snippets} directory, which could be copied to the installation directory using:"
msgstr "Emacs 包有时依赖于应与 Elisp 文件一并安装的资源目录。 @code{#:include} 参数可用于此目的，方法是指定要匹配的正则表达式列表。使用 @code{#:include} 参数时的最佳实践是扩展而不是覆盖它的默认值（可通过@code{%default-include} 变量访问）。 例如，yasnippet 扩展包通常包含一个 @file{snippets} 目录，可以使用以下命令将其复制到安装目录："

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

msgid "When encountering problems, it is wise to check for the presence of the @code{Package-Requires} extension header in the package main source file, and whether any dependencies and their versions listed therein are satisfied."
msgstr "当遇到问题时，明智的做法是检查包主要源文件中是否存在 @code{Package-Requires} 扩展标头，以及是否满足其中列出的任何依赖项及其版本。"

msgid "python"
msgstr "python"

msgid "Specifying Dependencies"
msgstr "指定依赖"

msgid "inputs, for Python packages"
msgstr "Python 软件包的输入"

msgid "Dependency information for Python packages is usually available in the package source tree, with varying degrees of accuracy: in the @file{pyproject.toml} file, the @file{setup.py} file, in @file{requirements.txt}, or in @file{tox.ini} (the latter mostly for test dependencies)."
msgstr "Python 软件包的依赖信息通常在包的源代码树里，各种文件有不同的准确度：@file{setup.py}文件，@file{requirements.txt}文件，或在 @file{tox.ini}文件（后者主要用于测试依赖项）。"

msgid "Python dependencies required at run time go into @code{propagated-inputs}.  They are typically defined with the @code{install_requires} keyword in @file{setup.py}, or in the @file{requirements.txt} file."
msgstr "运行时需要的 Python 依赖要放进@code{propagated-inputs}。它们通常由@file{setup.py}文件里的@code{install_requires}关键字或@file{requirements.txt}文件定义。"

msgid "Anything that does not fall in the previous categories goes to @code{inputs}, for example programs or C libraries required for building Python packages containing C extensions."
msgstr "任何不属于上述类别的包都要被加进@code{inputs}，如，构建含有 C 语言扩展的 Python包所需的程序和 C 语言库。"

msgid "If a Python package has optional dependencies (@code{extras_require}), it is up to you to decide whether to add them or not, based on their usefulness/overhead ratio (@pxref{Submitting Patches, @command{guix size}})."
msgstr "如果一个 Python 软件包由可选的依赖（@code{extras_require}），由你根据它们的性价比（用处/负担）决定是否添加它们（@pxref{Submitting Patches, @command{guix size}})."

msgid "perl"
msgstr "perl"

msgid "Perl programs standing for themselves are named as any other package, using the lowercase upstream name.  For Perl packages containing a single class, we use the lowercase class name, replace all occurrences of @code{::} by dashes and prepend the prefix @code{perl-}.  So the class @code{XML::Parser} becomes @code{perl-xml-parser}.  Modules containing several classes keep their lowercase upstream name and are also prepended by @code{perl-}.  Such modules tend to have the word @code{perl} somewhere in their name, which gets dropped in favor of the prefix.  For instance, @code{libwww-perl} becomes @code{perl-libwww}."
msgstr "Perl 程序和其它软件包的命名规则类似，用小写的上游名字命名。对于仅包含一个类的Perl 包，我们使用小写的类名，把所有的@code{::}替换成破折号，并且添加@code{perl-}前缀。所以类@code{XML::Parser}变成@code{perl-xml-parser}。包含多个类的模块保留它们上游的名字，并且添加@code{perl-}前缀。这类模块的名字通常含有@code{perl}，这个单词需要被删掉。例如，@code{libwww-perl}变成@code{perl-libwww}."

msgid "java"
msgstr "java"

msgid "Java programs standing for themselves are named as any other package, using the lowercase upstream name."
msgstr "Java 程序和其它软件包的命名规则类似，用小写的上游名字命名。"

msgid "To avoid confusion and naming clashes with other programming languages, it is desirable that the name of a package for a Java package is prefixed with @code{java-}.  If a project already contains the word @code{java}, we drop this; for instance, the package @code{ngsjava} is packaged under the name @code{java-ngs}."
msgstr "为了避免和其它编程语言混淆和命名冲突，Java 软件包的名字最好有@code{java-}前缀。如果一个项目的名字已经含有@code{java}，我们把它删掉；例如，@code{ngsjava}打包后的名字是@code{java-ngs}。"

msgid "For Java packages containing a single class or a small class hierarchy, we use the lowercase class name, replace all occurrences of @code{.} by dashes and prepend the prefix @code{java-}.  So the class @code{apache.commons.cli} becomes package @code{java-apache-commons-cli}."
msgstr "对于仅包含一个或很少几个类的 Java 软件包，我们使用小写的类名，把所有的@code{.}替换成破折号，并且添加@code{java-}前缀。因此，类@code{apache.commons.cli}打包后的名字是@code{java-apache-commons-cli}。"

msgid "rust"
msgstr "rust"

msgid "fonts"
msgstr "字体"

msgid "For fonts that are in general not installed by a user for typesetting purposes, or that are distributed as part of a larger software package, we rely on the general packaging rules for software; for instance, this applies to the fonts delivered as part of the X.Org system or fonts that are part of TeX Live."
msgstr "对于通常不会被用户安装用于排版的字体，或者随更大的软件包分发的字体，我们使用通常的命名规则。例如，这适用于 X.Org 系统附带的字体或 TeX Live 附带的字体。"

msgid "To make it easier for a user to search for fonts, names for other packages containing only fonts are constructed as follows, independently of the upstream package name."
msgstr "为了让用户更容易搜索字体，其它仅含有字体的软件包按以下规则命名，不管上游的包名是什么。"

msgid "The name of a package containing only one font family starts with @code{font-}; it is followed by the foundry name and a dash @code{-} if the foundry is known, and the font family name, in which spaces are replaced by dashes (and as usual, all upper case letters are transformed to lower case).  For example, the Gentium font family by SIL is packaged under the name @code{font-sil-gentium}."
msgstr "仅含有一个字体家族的软件包需要以@code{font-}开头；如果作者名字已知，则添加作者名字和@code{-}，接着是字体家族名字（把空格替换成破折号），（和通常一样，把所有的大写字母转换成小写字母）。例如，由 SIL 设计的 Gentium 字体家族打包后的名字是@code{font-sil-gentium}。"

msgid "For a package containing several font families, the name of the collection is used in the place of the font family name.  For instance, the Liberation fonts consist of three families, Liberation Sans, Liberation Serif and Liberation Mono.  These could be packaged separately under the names @code{font-liberation-sans} and so on; but as they are distributed together under a common name, we prefer to package them together as @code{font-liberation}."
msgstr "对于一个含有多个字体家族的软件包，用集合的名字替换字体家族的名字。例如，Liberation 字体含有三个家族，Liberation Sans、Liberation Serif 和 Liberation Mono。它们可以用@code{font-liberation-sans}等名字分开打包；但是由于它们以一个共同的名字分发，我们倾向于以@code{font-liberation}名字统一打包。"

msgid "In the case where several formats of the same font family or font collection are packaged separately, a short form of the format, prepended by a dash, is added to the package name.  We use @code{-ttf} for TrueType fonts, @code{-otf} for OpenType fonts and @code{-type1} for PostScript Type 1 fonts."
msgstr "当同一个字体家族或字体集合的不同格式分开打包时，把破折号和格式（缩写）添加在软件包名字后面。我们用@code{-ttf}代表 TrueType 字体，@code{-otf}代表 OpenType 字体，@code{-type1}代表 PostScript Type 1 字体。"

msgid "In general our code follows the GNU Coding Standards (@pxref{Top,,, standards, GNU Coding Standards}).  However, they do not say much about Scheme, so here are some additional rules."
msgstr "总的来说，我们的代码遵循 GNU 代码规范（@pxref{Top,,, standards, GNU 代码规范}）。但是，这个规范对 Scheme 的介绍不多，所以这儿提供一些额外的规则。"

msgid "Programming Paradigm"
msgstr "编程范例"

msgid "How to compose your elements."
msgstr "怎样合成元素。"

msgid "Modules"
msgstr "模块"

msgid "Where to store your code?"
msgstr "在哪里保存代码？"

msgid "Data Types and Pattern Matching"
msgstr "数据类型和模式匹配"

msgid "Implementing data structures."
msgstr "实现数据结构。"

msgid "Formatting Code"
msgstr "格式化代码"

msgid "Writing conventions."
msgstr "书写规范。"

msgid "Scheme code in Guix is written in a purely functional style.  One exception is code that involves input/output, and procedures that implement low-level concepts, such as the @code{memoize} procedure."
msgstr "Guix 里的 Scheme 代码是以纯函数的风格写的。一个例外是有关输入/输出的代码，和实现底层概念的过程，如@code{memoize}过程。"

msgid "Modules that deal with the broader GNU system should be in the @code{(gnu @dots{})} name space rather than @code{(guix @dots{})}."
msgstr "关于更广的 GNU 系统的模块应该在@code{(gnu @dots{})}命名空间里而不是@code{(guix @dots{})}."

msgid "The tendency in classical Lisp is to use lists to represent everything, and then to browse them ``by hand'' using @code{car}, @code{cdr}, @code{cadr}, and co.  There are several problems with that style, notably the fact that it is hard to read, error-prone, and a hindrance to proper type error reports."
msgstr "经典的 Lisp 倾向于用列表表示所有的东西，然后用@code{car}，@code{cdr}，@code{cadr}等手动浏览它们。这种风格有几个问题，特别是难以阅读，易出错，并且妨碍生成合适的类型错误报告。"

msgid "formatting code"
msgstr "格式化代码"

msgid "coding style"
msgstr "代码风格"

msgid "Some special forms introduced in Guix, such as the @code{substitute*} macro, have special indentation rules.  These are defined in the @file{.dir-locals.el} file, which Emacs automatically uses.  Also note that Emacs-Guix provides @code{guix-devel-mode} mode that indents and highlights Guix code properly (@pxref{Development,,, emacs-guix, The Emacs-Guix Reference Manual})."
msgstr "一些 Guix 添加的 special form，如@code{substitute*}宏，有特殊的缩进规则。它们的规则在@file{.dir-locals.el}文件里定义，Emacs 会自动使用。另外，Emacs-Guix 提供的@code{guix-devel-mode}模式可以正确地缩进和高亮 Guix 代码（@pxref{Development,,, emacs-guix, Emacs-Guix 参考手册}）。"

msgid "indentation, of code"
msgstr "代码缩进"

msgid "formatting, of code"
msgstr "代码格式化"

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

msgid "We require all top-level procedures to carry a docstring.  This requirement can be relaxed for simple private procedures in the @code{(guix build @dots{})} name space, though."
msgstr "我们要求所有的顶级过程附带一个 docstring。这个要求对@code{(guix build @dots{})}命名空间里的简单的私有过程可以放宽。"

msgid "Procedures should not have more than four positional parameters.  Use keyword parameters for procedures that take more than four parameters."
msgstr "过程不应该有多于四个定位参数。对于接收多于四个定位参数的过程应使用关键字参数。"

msgid "Please write commit logs in the ChangeLog format (@pxref{Change Logs,,, standards, GNU Coding Standards}); you can check the commit history for examples."
msgstr "请以 ChangeLog 格式（@pxref{Change Logs,,, standards, GNU 代码规范}）写 commit 日志；你可以浏览 commit 历史里的例子。"

msgid "Before submitting a patch that adds or modifies a package definition, please run through this check list:"
msgstr "提交添加或者修改软件包定义的补丁之前，请过一遍这个检查列表："

msgid "If the authors of the packaged software provide a cryptographic signature for the release tarball, make an effort to verify the authenticity of the archive.  For a detached GPG signature file this would be done with the @code{gpg --verify} command."
msgstr "如果软件包的作者为发布的文件包提供了密码学签名，请验证文件的真实性。对于独立的 GPG 签名文件，这可以通过 @code{gpg --verify} 命令完成。"

msgid "Take some time to provide an adequate synopsis and description for the package.  @xref{Synopses and Descriptions}, for some guidelines."
msgstr "花些时间为软件包提供一个合适的简介和描述。更多指导，@xref{Synopses and Descriptions}."

msgid "Run @command{guix lint @var{package}}, where @var{package} is the name of the new or modified package, and fix any errors it reports (@pxref{Invoking guix lint})."
msgstr "运行@command{guix lint @var{软件包}}，@var{软件包}是新添加的或修改过的软件包的名字，修复它报告的错误（@pxref{Invoking guix lint}）。"

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

msgid "Then reconfigure your system."
msgstr "然后重新配置你的系统。"

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

msgid "bundling"
msgstr "构建"

msgid "Make sure the package does not use bundled copies of software already available as separate packages."
msgstr "请确保软件包里不捆绑出现已经被打过包的软件的副本。"

msgid "Sometimes, packages include copies of the source code of their dependencies as a convenience for users.  However, as a distribution, we want to make sure that such packages end up using the copy we already have in the distribution, if there is one.  This improves resource usage (the dependency is built and stored only once), and allows the distribution to make transverse changes such as applying security updates for a given software package in a single place and have them affect the whole system---something that bundled copies prevent."
msgstr "有时，软件包为了方便用户，捆绑了依赖库的源代码。然而，当依赖库在发行版里已经存在时，做为一个发行版，我们希望确保这些软件包使用发行版里已有的副本。这提高资源使用率（依赖库只构建一次，存储一份），并且使发行版更容易管理，如仅在一个地方对某个软件包进行安全更新就可以影响整个系统－－捆绑软件会妨碍这么做。"

msgid "determinism, of build processes"
msgstr "构建过程的确定性"

msgid "reproducible builds, checking"
msgstr "检查可复现的构建"

msgid "Check whether the package's build process is deterministic.  This typically means checking whether an independent build of the package yields the exact same result that you obtained, bit for bit."
msgstr "检查软件包的构建过程是不是确定性的。这通常意味着检查对软件包的独立构建是否能得到每一个比特都完全相同的结果。"

msgid "A simple way to do that is by building the same package several times in a row on your machine (@pxref{Invoking guix build}):"
msgstr "为此，一个简单的做法是在你的机器上多次构建同一个软件包（@pxref{Invoking guix build}):"

msgid "guix build --rounds=2 my-package\n"
msgstr "guix build --rounds=2 <我的软件包>\n"

msgid "This is enough to catch a class of common non-determinism issues, such as timestamps or randomly-generated output in the build result."
msgstr "这足以查出一批普通的不确定性问题，如构建结果里存在时间戳或随机生成的输出。"

msgid "Another option is to use @command{guix challenge} (@pxref{Invoking guix challenge}).  You may run it once the package has been committed and built by @code{@value{SUBSTITUTE-SERVER-1}} to check whether it obtains the same result as you did.  Better yet: Find another machine that can build it and run @command{guix publish}.  Since the remote build machine is likely different from yours, this can catch non-determinism issues related to the hardware---e.g., use of different instruction set extensions---or to the operating system kernel---e.g., reliance on @code{uname} or @file{/proc} files."
msgstr "另一个选择是使用@command{guix challenge}（@pxref{Invoking guix challenge}）。当软件包被提交并且被@code{@value{SUBSTITUTE-SERVER-1}}构建之后，你可以运行这个命令检查你是否得到相同的构建结果。更好的：找另一台可以构建的机器，运行@command{guix publish}。由于远程的构建机器很可能和你的机器不同，这可以捕捉到由硬件不同引起的不确定性问题－－如，使用不同的指令集－－或不同操作系统内核引起的问题－－如，对@code{uname}或@file{/proc}文件的依赖。"

msgid "When writing documentation, please use gender-neutral wording when referring to people, such as @uref{https://en.wikipedia.org/wiki/Singular_they, singular ``they''@comma{} ``their''@comma{} ``them''}, and so forth."
msgstr "在编写文档时，请用性别中立的词语指代人，如@uref{https://en.wikipedia.org/wiki/Singular_they, “他”@comma{} “他的”}，等。"

msgid "Verify that your patch contains only one set of related changes.  Bundling unrelated changes together makes reviewing harder and slower."
msgstr "检查你的补丁只包含一些相关的更改。把不相关的更改捆绑在一起会让评审更困难和更慢。"

msgid "Examples of unrelated changes include the addition of several packages, or a package update along with fixes to that package."
msgstr "不相关的更改的例子有：同时新增多个软件包，或更新软件包同时修补这个软件包。"

msgid "When possible, use mirrors in the source URL (@pxref{Invoking guix download}).  Use reliable URLs, not generated ones.  For instance, GitHub archives are not necessarily identical from one generation to the next, so in this case it's often better to clone the repository.  Don't use the @code{name} field in the URL: it is not very useful and if the name changes, the URL will probably be wrong."
msgstr "当可能时，请在源 URL 里使用镜像@pxref{Invoking guix download}。使用可靠的而不是生成的 URL。例如，GitHub 的下载文件每次生成时不一定是相同的，所以这时最好克隆仓库。不要在 URL 里使用@code{name}变量：这没有什么用，而且如果名字变了，URL 很可能就错了。"

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

msgid "Configuring Git"
msgstr "配置 Git"

msgid "branching strategy"
msgstr "分支策略"

msgid "rebuild scheduling strategy"
msgstr "重新构建的调度策略"

msgid "Request for merging \"@var{name}\" branch\n"
msgstr "Request for merging \"@var{name}\" branch\n"

msgid "Warning"
msgstr "警告"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

msgid "@xref{Top,,, debbugs-ug, Debbugs User Guide}, for more information on this nifty tool!"
msgstr "@xref{Top,,, debbugs-ug, Debbugs User Guide}，了解更多有关此实用工具的信息！"

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

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

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

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

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

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

msgid "./etc/teams.scm sync-codeberg-teams @var{token}\n"
msgstr "./etc/teams.scm sync-codeberg-teams @var{token}\n"

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

msgid "All commits that are pushed to the central repository on Codeberg must be signed with an OpenPGP key, and the public key should be uploaded to your user account on Codeberg and to public key servers, such as @code{keys.openpgp.org}.  To configure Git to automatically sign commits, run:"
msgstr "所有推送到 Codeberg 中央存储库的提交必须使用 OpenPGP 密钥签名，并且公钥应上传到您在 Codeberg 的用户帐户和公共密钥服务器，例如 @code{keys.openpgp.org}。要配置 Git 自动签署提交，请运行："

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

msgid ""
"# Substitute the fingerprint of your public PGP key.\n"
"git config user.signingkey CABBA6EA1DC0FF33\n"
msgstr ""
"# 替换为您的公共 PGP 密钥指纹。\n"
"git config user.signingkey CABBA6EA1DC0FF33\n"

msgid "To avoid accidentally pushing unsigned or signed with the wrong key commits to Codeberg, make sure to configure Git according to @xref{Configuring Git}."
msgstr "为了避免意外将未签名或使用错误密钥签名的提交推送到 Codeberg，请确保根据 @xref{Configuring Git} 配置 Git。"

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

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

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

msgid "To guard against accidentally updating the @code{guix} package to a commit that others can't refer to, a check is made that the commit used has already been pushed to the Codeberg-hosted Guix Git repository."
msgstr "为了防止意外将 @code{guix} 包更新到其他人无法引用的提交，会检查所使用的提交是否已推送到 Codeberg 托管的 Guix Git 仓库。"

msgid "Services"
msgstr "服务"

msgid "documentation"
msgstr "documentation"

msgid "i18n"
msgstr "i18n"

msgid "On Weblate, you will find various links to the editor, that will show various subsets (or all) of the strings.  Have a look around and at the @uref{https://docs.weblate.org/en/latest/,documentation} to familiarize yourself with the platform."
msgstr ""
"在 Weblate 上，您可以发现各种编辑器链接，这些链接将显示各种字符串子集（或全部）。 请访问@uref{https://docs.weblate.org/zh-cn/latest/,文档}以熟悉该平台。\n"
"\n"
"@unnumberedsec 译者注意\n"
"\n"
"各位热爱 Guix 本地化的朋友，当您进行本地化工作时，需注意：\n"
"\n"
"中文标点符号的使用不能草率，应参考《标点符号用法》（GB/T 15834-2011）。\n"
"\n"
"对于中英文混合标点符号用法，应参考教育部发布的《夹用英文的中文文本的标点符号用法（草案）》。\n"
"\n"
"对于其他中文信息处理，应参考《汉语信息处理词汇 01部分：基本术语》（GB 12200.1-90）、《汉语信息处理词汇 02 部分：汉语和汉字》（GB/T 12200.2-94）、《出版物上数字用法》（GB/T 15835-2011）等教育部和国家语委发布的国家标准及语言文字规范。\n"
"\n"
"对于 “and/or” 的译法，建议采用“和（或）”而不是“和/或”。"

msgid "As an example, you cannot translate @samp{package '~a' has been superseded by '~a'} by @samp{'~a' supersedes package '~a'}, because the meaning would be reversed.  If @var{foo} is superseded by @var{bar}, the translation would read @samp{'foo' supersedes package 'bar'}.  To work around this problem, it is possible to use more advanced formatting to select a given piece of data, instead of following the default English order.  @xref{Formatted Output,,, guile, GNU Guile Reference Manual}, for more information on formatting in Guile."
msgstr "例如，您不能将 @samp{package '~a' has been superseded by '~a'} 翻译为 @samp{'~a' supersedes package '~a'}，因为意思会被颠倒。如果 @var{foo} 被 @var{bar} 取代，翻译将为 @samp{'foo' supersedes package 'bar'}。为了解决这个问题，可以使用更高级的格式来选择特定的数据，而不是遵循默认的英语顺序。有关 Guile 中格式的更多信息，请参阅 @pxref{Formatted Output,,, guile, GNU Guile Reference Manual}."

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

msgid "@documentencoding UTF-8"
msgstr ""
"@documentencoding UTF-8\n"
"@documentlanguage zh_CN"

msgid "GNU Guix Reference Manual"
msgstr "GNU Guix 参考手册"

msgid "version.texi"
msgstr "version-zh_CN.texi"

msgid "Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.  A copy of the license is included in the section entitled ``GNU Free Documentation License''."
msgstr "现允许根据 GNU 自由文档许可证第 1.3 版或自由软件基金会发布的任何更高版本的条款复制、分发和（或）修改本文件；没有不可变小节，没有封面文字，也没有封底文字。此许可证的副本包含在标题为“GNU 自由文档许可证”的部分内。"

msgid "System administration"
msgstr "系统管理"

msgid "Guix: (guix)"
msgstr "Guix.zh_CN: (guix.zh_CN)"

msgid "Manage installed software and system configuration."
msgstr "管理安装的软件和系统配置。"

msgid "guix package: (guix)Invoking guix package"
msgstr "guix package: (guix.zh_CN) 调用 guix package"

msgid "Installing, removing, and upgrading packages."
msgstr "安装、删除和升级软件包。"

msgid "guix gc: (guix)Invoking guix gc"
msgstr "guix gc：(guix.zh_CN) 调用 guix gc"

msgid "Reclaiming unused disk space."
msgstr "回收不使用的硬盘空间。"

msgid "guix pull: (guix)Invoking guix pull"
msgstr "guix pull: (guix.zh_CN) 调用 guix pull"

msgid "Update the list of available packages."
msgstr "更新可用的软件包列表。"

msgid "guix system: (guix)Invoking guix system"
msgstr "guix system: (guix.zh_CN) 调用 guix system"

msgid "Manage the operating system configuration."
msgstr "管理操作系统配置。"

msgid "guix deploy: (guix)Invoking guix deploy"
msgstr "guix deploy: (guix.zh_CN) 调用 guix deploy"

msgid "Software development"
msgstr "软件开发"

msgid "guix shell: (guix)Invoking guix shell"
msgstr "guix shell: (guix.zh_CN) 调用 guix shell"

msgid "guix environment: (guix)Invoking guix environment"
msgstr "guix environment: (guix.zh_CN) 调用 guix environment"

msgid "Building development environments with Guix."
msgstr "用 Guix 构建开发环境。"

msgid "guix build: (guix)Invoking guix build"
msgstr "guix build: (guix.zh_CN) 调用 guix build"

msgid "Building packages."
msgstr "构建软件包。"

msgid "guix pack: (guix)Invoking guix pack"
msgstr "guix pack: (guix.zh_CN) 调用 guix pack"

msgid "Creating binary bundles."
msgstr "创建二进制 bundle。"

msgid "Using the GNU Guix Functional Package Manager"
msgstr "使用 GNU Guix 函数式包管理器"

msgid "The GNU Guix Developers"
msgstr "GNU Guix 开发者"

msgid "Edition @value{EDITION} @* @value{UPDATED} @*"
msgstr "版本@value{EDITION} @* @value{UPDATED} @*"

msgid "Top"
msgstr "Top"

msgid "GNU Guix"
msgstr "GNU Guix"

msgid "This document describes GNU Guix version @value{VERSION}, a functional package management tool written for the GNU system."
msgstr ""
"这份文档介绍 GNU Guix 版本 @value{VERSION}，一个为 GNU 系统编写的函数式包管理器。\n"
"\n"
"因语言差异导致的语义折损深表歉意，术语溯源详见英文版。"

msgid "This manual is also available in Simplified Chinese (@pxref{Top,,, guix.zh_CN, GNU Guix参考手册}), French (@pxref{Top,,, guix.fr, Manuel de référence de GNU Guix}), German (@pxref{Top,,, guix.de, Referenzhandbuch zu GNU Guix}), Spanish (@pxref{Top,,, guix.es, Manual de referencia de GNU Guix}), Italian (@pxref{Top,,, guix.it, Manuale di riferimento di GNU Guix}), Brazilian Portuguese (@pxref{Top,,, guix.pt_BR, Manual de referência do GNU Guix}), and Russian (@pxref{Top,,, guix.ru, Руководство GNU Guix}).  If you would like to translate it in your native language, consider joining @uref{https://translate.codeberg.org/projects/guix/documentation-manual, Weblate} (@pxref{Translating Guix})."
msgstr "这个用户手册还提供英语版（@pxref{Top,,, guix, GNU Guix Reference Manual}）、法语版（@pxref{Top,,, guix.fr, Manuel de référence de GNU Guix}）、德语版（@pxref{Top,,, guix.de, Referenzhandbuch zu GNU Guix}）、西班牙语版（@pxref{Top,,, guix.es, Manual de referencia de GNU Guix}）、意大利语版（@pxref{Top,,, guix.it, Manuale di riferimento di GNU Guix}）、巴西葡萄牙语版（@pxref{Top,,, guix.pt_BR, Manual de referência do GNU Guix}）与俄语版（@pxref{Top,,, guix.ru, Руководство GNU Guix}）。如果你想把它翻译成你的母语，请考虑加入 @uref{https://translate.codeberg.org/projects/guix/documentation-manual, Weblate}（@pxref{Translating Guix}）。"

msgid "What is Guix about?"
msgstr "Guix 是关于什么的？"

msgid "Installation"
msgstr "安装"

msgid "Installing Guix."
msgstr "安装 Guix。"

msgid "System Installation"
msgstr "系统安装"

msgid "Installing the whole operating system."
msgstr "安装整个操作系统。"

msgid "Getting Started"
msgstr "入门"

msgid "Package Management"
msgstr "软件包管理"

msgid "Package installation, upgrade, etc."
msgstr "软件包安装、升级等。"

msgid "Channels"
msgstr "频道"

msgid "Customizing the package collection."
msgstr "定制软件包集合。"

msgid "Development"
msgstr "开发"

msgid "Guix-aided software development."
msgstr "Guix 辅助的软件开发。"

msgid "Programming Interface"
msgstr "编程接口"

msgid "Using Guix in Scheme."
msgstr "在 Scheme 里使用 Guix。"

msgid "Utilities"
msgstr "工具"

msgid "Package management commands."
msgstr "软件包管理命令。"

msgid "System Configuration"
msgstr "系统配置"

msgid "Configuring the operating system."
msgstr "配置操作系统。"

msgid "Documentation"
msgstr "文档"

msgid "Browsing software user manuals."
msgstr "浏览软件用户手册。"

msgid "Platforms"
msgstr "平台"

msgid "Installing Debugging Files"
msgstr "安装调试文件"

msgid "Feeding the debugger."
msgstr "为调试工具提供输入。"

msgid "Security Updates"
msgstr "安全更新"

msgid "Deploying security fixes quickly."
msgstr "快速部署安全补丁。"

msgid "Bootstrapping"
msgstr "引导"

msgid "GNU/Linux built from scratch."
msgstr "从头开始构建 GNU/Linux。"

msgid "Porting"
msgstr "移植"

msgid "Targeting another platform or kernel."
msgstr "以别的平台或内核为目标。"

msgid "Your help needed!"
msgstr "你需要帮助！"

msgid "Acknowledgments"
msgstr "致谢"

msgid "Thanks!"
msgstr "感谢！"

msgid "GNU Free Documentation License"
msgstr "GNU 自由文档许可证"

msgid "The license of this manual."
msgstr "这个用户手册的许可证。"

msgid "Concept Index"
msgstr "概念索引"

msgid "Concepts."
msgstr "概念。"

msgid "Programming Index"
msgstr "编程索引"

msgid "Data types, functions, and variables."
msgstr "数据类型、函数和变量。"

msgid "--- The Detailed Node Listing ---"
msgstr "－－－详细的章节列表－－－"

msgid "Managing Software the Guix Way"
msgstr "以 Guix 的方式管理软件"

msgid "What's special."
msgstr "特殊的地方。"

msgid "GNU Distribution"
msgstr "GNU 发行版"

msgid "The packages and tools."
msgstr "软件包和工具。"

msgid "Binary Installation"
msgstr "二进制文件安装"

msgid "Getting Guix running in no time!"
msgstr "立刻运行 Guix！"

msgid "Setting Up the Daemon"
msgstr "设置后台进程"

msgid "Preparing the build daemon's environment."
msgstr "准备“构建后台进程”的环境。"

msgid "Invoking guix-daemon"
msgstr "调用 guix-daemon"

msgid "Running the build daemon."
msgstr "运行后台构建进程。"

msgid "Application Setup"
msgstr "设置应用程序"

msgid "Application-specific setup."
msgstr "应用程序相关的设置。"

msgid "Upgrading Guix"
msgstr "升级 Guix"

msgid "Upgrading Guix and its build daemon."
msgstr "升级 Guix 及其构建守护进程。"

msgid "Build Environment Setup"
msgstr "设置构建环境"

msgid "Preparing the isolated build environment."
msgstr "准备隔离的构建环境。"

msgid "Daemon Offload Setup"
msgstr "下发工作给后台进程的设置"

msgid "Offloading builds to remote machines."
msgstr "下发构建工作给远程的机器。"

msgid "SELinux Support"
msgstr "SELinux 的支持"

msgid "Using an SELinux policy for the daemon."
msgstr "为后台进程使用 SELinux 规则。"

msgid "Limitations"
msgstr "限制"

msgid "What you can expect."
msgstr "你可以期待什么。"

msgid "Hardware Considerations"
msgstr "硬件的考虑"

msgid "Supported hardware."
msgstr "支持的硬件。"

msgid "USB Stick and DVD Installation"
msgstr "U 盘和 DVD 安装"

msgid "Preparing the installation medium."
msgstr "准备安装介质。"

msgid "Preparing for Installation"
msgstr "准备安装"

msgid "Networking, partitioning, etc."
msgstr "网络、分区等。"

msgid "Guided Graphical Installation"
msgstr "向导式图形安装"

msgid "Easy graphical installation."
msgstr "简单的图形安装。"

msgid "Manual Installation"
msgstr "手动安装"

msgid "Manual installation for wizards."
msgstr "适合巫师的手动安装。"

msgid "After System Installation"
msgstr "系统安装之后"

msgid "When installation succeeded."
msgstr "当安装成功后。"

msgid "Installing Guix in a VM"
msgstr "在虚拟机里安装 Guix"

msgid "Guix System playground."
msgstr "Guix 系统游乐场。"

msgid "Building the Installation Image"
msgstr "构建安装镜像"

msgid "How this comes to be."
msgstr "这是怎样实现的。"

msgid "Keyboard Layout and Networking and Partitioning"
msgstr "键盘布局、网络和分区"

msgid "Initial setup."
msgstr "初始设置。"

msgid "Proceeding with the Installation"
msgstr "继续安装步骤"

msgid "Installing."
msgstr "安装。"

msgid "Features"
msgstr "功能"

msgid "How Guix will make your life brighter."
msgstr "Guix 怎样让你的生活更美好。"

msgid "Invoking guix package"
msgstr "调用 guix package"

msgid "Package installation, removal, etc."
msgstr "软件包安装，移除等。"

msgid "Substitutes"
msgstr "替代品"

msgid "Downloading pre-built binaries."
msgstr "下载构建好的二进制文件。"

msgid "Packages with Multiple Outputs"
msgstr "有多个输出的软件包"

msgid "Single source package, multiple outputs."
msgstr "单个输入多个输出的软件包。"

msgid "Invoking guix locate"
msgstr "调用 guix locate"

msgid "Invoking guix gc"
msgstr "调用 guix gc"

msgid "Running the garbage collector."
msgstr "运行垃圾回收器。"

msgid "Invoking guix pull"
msgstr "调用 guix pull"

msgid "Fetching the latest Guix and distribution."
msgstr "获取最新的 Guix 和发行版。"

msgid "Invoking guix time-machine"
msgstr "调用 guix time-machine"

msgid "Inferiors"
msgstr "下级"

msgid "Interacting with another revision of Guix."
msgstr "和其它版本的 Guix 交互。"

msgid "Invoking guix describe"
msgstr "调用 guix describe"

msgid "Display information about your Guix revision."
msgstr "显示你的 Guix 版本信息。"

msgid "Invoking guix archive"
msgstr "调用 guix archive"

msgid "Exporting and importing store files."
msgstr "导出和导入仓库文件。"

msgid "One particular source of substitutes."
msgstr "substitute 的一个特殊来源。"

msgid "Substitute Server Authorization"
msgstr "substitute 服务器授权"

msgid "How to enable or disable substitutes."
msgstr "怎么开启或关闭 substitute。"

msgid "Substitute diversity."
msgstr "substitutes 多样化。"

msgid "Substitute Authentication"
msgstr "验证 substitute"

msgid "How Guix verifies substitutes."
msgstr "Guix 怎样验证 substitute。"

msgid "Proxy Settings"
msgstr "代理设置"

msgid "How to get substitutes via proxy."
msgstr "怎样通过代理获取 substitute。"

msgid "Substitution Failure"
msgstr "substitute 失败"

msgid "What happens when substitution fails."
msgstr "当 substitute 失败时会发生什么。"

msgid "On Trusting Binaries"
msgstr "关于信任二进制文件"

msgid "How can you trust that binary blob?"
msgstr "你怎么能信任二进制的 blob 呢？"

msgid "Specifying Additional Channels"
msgstr "指定其他频道"

msgid "Extending the package collection."
msgstr "拓展软件包集合。"

msgid "Using a Custom Guix Channel"
msgstr "使用自定义 Guix 频道"

msgid "Replicating Guix"
msgstr "复制 Guix"

msgid "Channel Authentication"
msgstr "频道验证"

msgid "Creating a Channel"
msgstr "创建一个频道"

msgid "Writing Channel News"
msgstr "撰写频道新闻"

msgid "Invoking guix shell"
msgstr "调用 guix shell"

msgid "Invoking guix environment"
msgstr "调用 guix environment"

msgid "Setting up development environments."
msgstr "设置开发环境。"

msgid "Invoking guix pack"
msgstr "调用 guix pack"

msgid "Creating software bundles."
msgstr "创建软件 bundle。"

msgid "The GCC toolchain"
msgstr "GCC 工具链"

msgid "Invoking guix git authenticate"
msgstr "调用 guix git authenticate"

msgid "Package Modules"
msgstr "软件包模块"

msgid "Packages from the programmer's viewpoint."
msgstr "从程序员的角度看软件包。"

msgid "Defining Packages"
msgstr "定义软件包"

msgid "Defining new packages."
msgstr "定义新软件包。"

msgid "Defining Package Variants"
msgstr "定义软件包变体"

msgid "Writing Manifests"
msgstr "书写清单"

msgid "Build Systems"
msgstr "构建系统"

msgid "Specifying how packages are built."
msgstr "指定如何构建软件包。"

msgid "Build Utilities"
msgstr "构建工具"

msgid "Search Paths"
msgstr "搜索路径"

msgid "The Store"
msgstr "存储区"

msgid "Manipulating the package store."
msgstr "操纵软件包仓库。"

msgid "Derivations"
msgstr "派生"

msgid "Low-level interface to package derivations."
msgstr "软件包 derivation 的底层接口。"

msgid "The Store Monad"
msgstr "存储区单子"

msgid "Purely functional interface to the store."
msgstr "仓库的纯函数式接口。"

msgid "G-Expressions"
msgstr "G-表达式"

msgid "Manipulating build expressions."
msgstr "操纵构建表达式。"

msgid "Invoking guix repl"
msgstr "调用 guix repl"

msgid "Using Guix Interactively"
msgstr "交互式使用 Guix"

msgid "package Reference"
msgstr "软件包引用"

msgid "The package data type."
msgstr "软件包数据类型。"

msgid "origin Reference"
msgstr "origin 参考手册"

msgid "The origin data type."
msgstr "origin 数据类型。"

msgid "Invoking guix build"
msgstr "调用 guix build"

msgid "Building packages from the command line."
msgstr "用命令行构建软件包。"

msgid "Invoking guix edit"
msgstr "调用 guix edit"

msgid "Editing package definitions."
msgstr "编辑软件包定义。"

msgid "Invoking guix download"
msgstr "调用 guix download"

msgid "Downloading a file and printing its hash."
msgstr "下载一个文件并打印它的 hash。"

msgid "Invoking guix hash"
msgstr "调用 guix hash"

msgid "Computing the cryptographic hash of a file."
msgstr "计算一个文件的密码学 hash。"

msgid "Invoking guix import"
msgstr "调用 guix import"

msgid "Importing package definitions."
msgstr "导入软件包定义。"

msgid "Invoking guix refresh"
msgstr "调用 guix refresh"

msgid "Updating package definitions."
msgstr "更新软件包定义。"

msgid "Invoking guix style"
msgstr "调用 guix style"

msgid "Invoking guix lint"
msgstr "调用 guix lint"

msgid "Finding errors in package definitions."
msgstr "从软件包定义里寻找错误。"

msgid "Invoking guix size"
msgstr "调用 guix size"

msgid "Profiling disk usage."
msgstr "分析硬盘使用情况。"

msgid "Invoking guix graph"
msgstr "调用 guix graph"

msgid "Visualizing the graph of packages."
msgstr "展示软件包的关系图。"

msgid "Invoking guix publish"
msgstr "调用 guix publish"

msgid "Sharing substitutes."
msgstr "分享 substitute。"

msgid "Invoking guix challenge"
msgstr "调用 guix challenge"

msgid "Challenging substitute servers."
msgstr "挑战 subtitute 服务器。"

msgid "Invoking guix copy"
msgstr "调用 guix copy"

msgid "Copying to and from a remote store."
msgstr "复制到远程的仓库，或从远程的仓库复制。"

msgid "Invoking guix container"
msgstr "调用 guix container"

msgid "Process isolation."
msgstr "进程隔离。"

msgid "Invoking guix weather"
msgstr "调用 guix weather"

msgid "Assessing substitute availability."
msgstr "评估 substitute 的可用性。"

msgid "Invoking guix processes"
msgstr "调用 guix processes"

msgid "Listing client processes."
msgstr "列出客户端进程。"

msgid "Invoking @command{guix build}"
msgstr "调用 @command{guix build}"

msgid "Common Build Options"
msgstr "普通的构建选项"

msgid "Build options for most commands."
msgstr "大部分命令的构建选项。"

msgid "Package Transformation Options"
msgstr "软件包转换选项"

msgid "Creating variants of packages."
msgstr "创建软件包的变体。"

msgid "Additional Build Options"
msgstr "额外的构建选项"

msgid "Options specific to 'guix build'."
msgstr "只属于'guix build'的选项。"

msgid "Debugging Build Failures"
msgstr "调试构建错误"

msgid "Real life packaging experience."
msgstr "真实的打包经验。"

msgid "Cross-Compilation"
msgstr "交叉编译"

msgid "Cross-compiling for another architecture."
msgstr "为另一个架构交叉编译。"

msgid "Native Builds"
msgstr "本地构建"

msgid "Using the Configuration System"
msgstr "使用配置系统"

msgid "Customizing your GNU system."
msgstr "定制你的 GNU 系统。"

msgid "operating-system Reference"
msgstr "operating-system 参考"

msgid "Detail of operating-system declarations."
msgstr "操作系统声明详情。"

msgid "File Systems"
msgstr "文件系统"

msgid "Configuring file system mounts."
msgstr "设置文件系统挂载。"

msgid "Mapped Devices"
msgstr "映射的设备"

msgid "Block device extra processing."
msgstr "块设备额外的处理。"

msgid "Swap Space"
msgstr "交换空间"

msgid "User Accounts"
msgstr "用户帐户"

msgid "Specifying user accounts."
msgstr "指定用户帐户。"

msgid "Keyboard Layout"
msgstr "键盘布局"

msgid "How the system interprets key strokes."
msgstr "系统怎样理解按键。"

msgid "Locales"
msgstr "区域"

msgid "Language and cultural convention settings."
msgstr "语言和文化惯例设置。"

msgid "Specifying system services."
msgstr "指定系统服务。"

msgid "Privileged Programs"
msgstr "特权程序"

msgid "X.509 Certificates"
msgstr "X.509 证书"

msgid "Authenticating HTTPS servers."
msgstr "认证 HTTPS 服务器。"

msgid "Name Service Switch"
msgstr "Name Service Switch"

msgid "Configuring libc's name service switch."
msgstr "设置 libc 的 name service switch。"

msgid "Initial RAM Disk"
msgstr "初始化内存盘"

msgid "Linux-Libre bootstrapping."
msgstr "Linux-Libre 引导。"

msgid "Bootloader Configuration"
msgstr "引导配置"

msgid "Configuring the boot loader."
msgstr "设置引导程序。"

msgid "Invoking guix system"
msgstr "调用 guix system"

msgid "Instantiating a system configuration."
msgstr "实例化一个系统配置。"

msgid "Invoking guix deploy"
msgstr "调用 guix deploy"

msgid "Running Guix in a VM"
msgstr "在虚拟机里运行 Guix"

msgid "How to run Guix System in a virtual machine."
msgstr "怎样在虚拟机里运行 Guix。"

msgid "Defining Services"
msgstr "定义服务"

msgid "Adding new service definitions."
msgstr "添加新的服务定义。"

msgid "Btrfs file system"
msgstr "Btrfs 文件系统"

msgid "Base Services"
msgstr "基础服务"

msgid "Essential system services."
msgstr "必要的系统服务。"

msgid "Scheduled Job Execution"
msgstr "执行计划任务"

msgid "The mcron service."
msgstr "mcron 服务。"

msgid "Log Rotation"
msgstr "日志轮替"

msgid "Setting up network interfaces."
msgstr "配置网络接口。"

msgid "Networking Services"
msgstr "网络服务"

msgid "Firewall, SSH daemon, etc."
msgstr "防火墙，SSH 后台进程等。"

msgid "X Window"
msgstr "X 窗口"

msgid "Graphical display."
msgstr "图形显示器。"

msgid "Printing Services"
msgstr "打印服务"

msgid "Local and remote printer support."
msgstr "本地和远程打印机的支持。"

msgid "Desktop Services"
msgstr "桌面服务"

msgid "D-Bus and desktop services."
msgstr "D-Bus 和桌面服务。"

msgid "Sound Services"
msgstr "声音服务"

msgid "ALSA and Pulseaudio services."
msgstr "ALSA 和 Pulseaudio 服务。"

msgid "Database Services"
msgstr "数据库服务"

msgid "SQL databases, key-value stores, etc."
msgstr "SQL 数据库，键值仓库等。"

msgid "Mail Services"
msgstr "邮件服务"

msgid "IMAP, POP3, SMTP, and all that."
msgstr "IMAP，POP3，SMTP 等。"

msgid "Messaging Services"
msgstr "消息服务"

msgid "Messaging services."
msgstr "消息服务。"

msgid "Telephony Services"
msgstr "电话服务"

msgid "Telephony services."
msgstr "电话服务。"

msgid "Monitoring Services"
msgstr "监控服务"

msgid "Monitoring services."
msgstr "监控服务。"

msgid "Kerberos Services"
msgstr "Kerberos 服务"

msgid "Kerberos services."
msgstr "Kerberos 服务。"

msgid "Web Services"
msgstr "Web 服务"

msgid "Web servers."
msgstr "Web 服务。"

msgid "Certificate Services"
msgstr "证书服务"

msgid "TLS certificates via Let's Encrypt."
msgstr "Let's Encrypt TLS 证书。"

msgid "DNS Services"
msgstr "DNS 服务"

msgid "DNS daemons."
msgstr "DNS 后台进程。"

msgid "VPN Services"
msgstr "VPN 服务"

msgid "VPN daemons."
msgstr "VPN 后台进程。"

msgid "Network File System"
msgstr "网络文件系统"

msgid "NFS related services."
msgstr "网络文件系统相关的服务。"

msgid "Continuous Integration"
msgstr "持续集成"

msgid "Power Management Services"
msgstr "电源管理服务"

msgid "Audio Services"
msgstr "音频服务"

msgid "The MPD."
msgstr "MPD。"

msgid "Virtualization Services"
msgstr "虚拟化服务"

msgid "Virtualization services."
msgstr "虚拟化服务。"

msgid "Version Control Services"
msgstr "版本控制服务"

msgid "Game Services"
msgstr "游戏服务"

msgid "Game servers."
msgstr "游戏服务器。"

msgid "Miscellaneous Services"
msgstr "其它各种服务"

msgid "Other services."
msgstr "其它服务。"

msgid "Service Composition"
msgstr "合成服务"

msgid "The model for composing services."
msgstr "服务合成的模型。"

msgid "Service Types and Services"
msgstr "服务类型和服务"

msgid "Types and services."
msgstr "类型和服务。"

msgid "Service Reference"
msgstr "服务参考"

msgid "API reference."
msgstr "API 参考。"

msgid "Shepherd Services"
msgstr "Shepherd 服务"

msgid "A particular type of service."
msgstr "一种特别的服务。"

msgid "Chrooting into an existing system"
msgstr "改变目录进入现有系统"

msgid "Configuring the Shell"
msgstr "配置 Shell"

msgid "Home Services"
msgstr "家服务"

msgid "Invoking guix home"
msgstr "调用 guix home"

msgid "Networking services."
msgstr "网络服务。"

msgid "Creating System Images"
msgstr "创建系统镜像"

msgid "@code{image} Reference"
msgstr "@code{image} 参考手册"

msgid "partition Reference"
msgstr "partition 参考手册"

msgid "Installing 'debug' outputs."
msgstr "安装“调试”输出"

msgid "purpose"
msgstr "目的"

msgid "GNU Guix@footnote{``Guix'' is pronounced like ``geeks'', or ``ɡiːks'' using the international phonetic alphabet (IPA).} is a package management tool for and distribution of the GNU system.  Guix makes it easy for unprivileged users to install, upgrade, or remove software packages, to roll back to a previous package set, to build packages from source, and generally assists with the creation and maintenance of software environments."
msgstr "GNU Guix@footnote{``Guix''读做 ``geeks''，或``ɡiːks''（国际音标）}是 GNU 系统的包管理器和发行版。Guix 让无特权的用户可以轻松地安装，升级，或删除软件包，回滚到前一个软件包集合，从源代码构建软件包，及辅助软件环境的创建和维护。"

msgid "Guix System"
msgstr "Guix 系统"

msgid "GuixSD, now Guix System"
msgstr "GuixSD，现在称为 Guix 系统"

msgid "Guix System Distribution, now Guix System"
msgstr "Guix 系统发行版，现在称为 Guix 系统"

msgid "You can install GNU@tie{}Guix on top of an existing GNU/Linux system where it complements the available tools without interference (@pxref{Installation}), or you can use it as a standalone operating system distribution, @dfn{Guix@tie{}System}@footnote{We used to refer to Guix System as ``Guix System Distribution'' or ``GuixSD''.  We now consider it makes more sense to group everything under the ``Guix'' banner since, after all, Guix System is readily available through the @command{guix system} command, even if you're using a different distro underneath!}.  @xref{GNU Distribution}."
msgstr "你可以在现有的 GNU/Linux 发行版上安装 GNU@tie{}Guix（@pxref{Installation}），Guix 可以补充已有的工具，并且不会和它们产生冲突。或者你可以把它当作独立的操作系统发行版（@dfn{Guix@tie{}系统}@footnote{我们以前把 Guix 系统称为``Guix 系统发行版''或 ``GuixSD''。我们现在觉得把一切都统一在``Guix''的旗帜下更合理，因为，毕竟即使在别的发行版上你也可以随时通过@command{guix system}命令获得 Guix 系统}）。@xref{GNU Distribution}."

msgid "user interfaces"
msgstr "用户界面"

msgid "Guix provides a command-line package management interface (@pxref{Package Management}), tools to help with software development (@pxref{Development}), command-line utilities for more advanced usage (@pxref{Utilities}), as well as Scheme programming interfaces (@pxref{Programming Interface})."
msgstr "Guix 提供了命令行软件包管理接口（@pxref{Package Management}），辅助软件开发的工具（@pxref{Development}），高级用法的命令行接口（@pxref{Utilities}），以及Scheme 编程语言接口（@pxref{Programming Interface}）。"

msgid "build daemon"
msgstr "构建后台进程"

msgid "Its @dfn{build daemon} is responsible for building packages on behalf of users (@pxref{Setting Up the Daemon}) and for downloading pre-built binaries from authorized sources (@pxref{Substitutes})."
msgstr "@dfn{构建后台进程}为用户构建软件包（@pxref{Setting Up the Daemon}），及从授权的源（@pxref{Substitutes}）下载预构建的二进制文件。"

msgid "extensibility of the distribution"
msgstr "发行版的扩展性"

msgid "customization, of packages"
msgstr "定制软件包"

msgid "Guix includes package definitions for many GNU and non-GNU packages, all of which @uref{https://www.gnu.org/philosophy/free-sw.html, respect the user's computing freedom}.  It is @emph{extensible}: users can write their own package definitions (@pxref{Defining Packages}) and make them available as independent package modules (@pxref{Package Modules}).  It is also @emph{customizable}: users can @emph{derive} specialized package definitions from existing ones, including from the command line (@pxref{Package Transformation Options})."
msgstr "Guix 包含很多 GNU 和非 GNU 的软件包定义，所有的这些软件包都@uref{https://www.gnu.org/philosophy/free-sw.html, 尊重用户的自由}。它是@emph{可扩展的}：用户可以编写自己的软件包定义（@pxref{Defining Packages}），并且把它们作为独立的软件包模块@pxref{Package Modules}。它也是@emph{可定制的}：用户可以从现有的软件包定义衍生出特殊的软件包，包括从命令行（@pxref{Package Transformation Options}）。"

msgid "functional package management"
msgstr "函数式包管理器"

msgid "isolation"
msgstr "隔离"

msgid "Under the hood, Guix implements the @dfn{functional package management} discipline pioneered by Nix (@pxref{Acknowledgments}).  In Guix, the package build and installation process is seen as a @emph{function}, in the mathematical sense.  That function takes inputs, such as build scripts, a compiler, and libraries, and returns an installed package.  As a pure function, its result depends solely on its inputs---for instance, it cannot refer to software or scripts that were not explicitly passed as inputs.  A build function always produces the same result when passed a given set of inputs.  It cannot alter the environment of the running system in any way; for instance, it cannot create, modify, or delete files outside of its build and installation directories.  This is achieved by running build processes in isolated environments (or @dfn{containers}), where only their explicit inputs are visible."
msgstr "在底层，Guix 实现了由 Nix（@pxref{Acknowledgments}）开创的@dfn{函数式包管理器}。在 Guix 里，软件包构建和安装过程被视为数学意义上的@emph{函数}。函数获取输入，如构建脚本、编译器和库，并且返回一个安装好的软件包。作为一个纯函数，它的结果只取决于它的输入－－例如，它不能引用没有作为显式输入传入的软件和脚本。当传入特定的输入时，一个构建函数总是得到相同的结果。它不能以任何方式修改运行系统的环境，例如，它不能创建，修改，或删除构建和安装环境之外的文件夹。这是通过在隔离的环境（@dfn{容器}）里运行构建进程实现的，在这个环境里只能访问到显式的输入。"

msgid "store"
msgstr "store"

msgid "The result of package build functions is @dfn{cached} in the file system, in a special directory called @dfn{the store} (@pxref{The Store}).  Each package is installed in a directory of its own in the store---by default under @file{/gnu/store}.  The directory name contains a hash of all the inputs used to build that package; thus, changing an input yields a different directory name."
msgstr "软件包构建函数的结果被@dfn{缓存}在文件系统里的一个叫做@dfn{仓库}（@pxref{The Store}）的特殊文件夹内。每个软件包都被安装在仓库（默认在@file{/gnu/store}）里的一个独立的文件夹内。这个文件夹的名字含有用于构建这个软件包的所有输入的hash，所以，修改输入会得到一个不同的文件夹名。"

msgid "This approach is the foundation for the salient features of Guix: support for transactional package upgrade and rollback, per-user installation, and garbage collection of packages (@pxref{Features})."
msgstr "这种手段是实现 Guix 的突出功能的基础：对事务型软件包升级和回滚的支持，每个用户独立的安装，软件包垃圾回收@pxref{Features}。"

msgid "Guix comes with a distribution of the GNU system consisting entirely of free software@footnote{The term ``free'' here refers to the @url{https://www.gnu.org/philosophy/free-sw.html,freedom provided to users of that software}.}.  The distribution can be installed on its own (@pxref{System Installation}), but it is also possible to install Guix as a package manager on top of an installed GNU/Linux system (@pxref{Installation}).  When we need to distinguish between the two, we refer to the standalone distribution as Guix@tie{}System."
msgstr "Guix 提供了一个 GNU 系统发行版，这个发行版只包含自由软件@footnote{这里的“自由”指的是@url{https://www.gnu.org/philosophy/free-sw.html，软件提供给用户的自由}。}。这个发行版可以独立安装（@pxref{System Installation}），但是把 Guix 安装为一个已经安装好的 GNU/Linux 系统的包管理器也是可行的（@pxref{Installation}）。当我们需要区分这两者时，我们把独立的发行版称为“Guix 系统”。"

msgid "The distribution provides core GNU packages such as GNU libc, GCC, and Binutils, as well as many GNU and non-GNU applications.  The complete list of available packages can be browsed @url{https://www.gnu.org/software/guix/packages,on-line} or by running @command{guix package} (@pxref{Invoking guix package}):"
msgstr "这个发行版提供了 GNU 核心软件包，如 libc、gcc 和 Binutils，以及很多 GNU 和非 GNU 应用程序。可用的软件包的完整列表可以在@url{https://www.gnu.org/software/guix/packages,on-line}浏览，或者通过运行@command{guix package}（@pxref{Invoking guix package}）获得："

msgid "guix package --list-available\n"
msgstr "guix package --list-available\n"

msgid "Our goal is to provide a practical 100% free software distribution of Linux-based and other variants of GNU, with a focus on the promotion and tight integration of GNU components, and an emphasis on programs and tools that help users exert that freedom."
msgstr "我们的目标是提供一个基于 Linux 和其它 GNU 变体的可用的 100% 自由的软件发行版，我们的重点是推广和紧密集成 GNU 组件，以及强调帮助用户行使那些自由的程序和工具。"

msgid "Packages are currently available on the following platforms:"
msgstr "目前这些平台提供软件包："

msgid "x86_64-linux"
msgstr "x86_64-linux"

msgid "Intel/AMD @code{x86_64} architecture, Linux-Libre kernel."
msgstr "Intel/AMD @code{x86_64} 架构，Linux-Libre 内核。"

msgid "i686-linux"
msgstr "i686-linux"

msgid "Intel 32-bit architecture (IA32), Linux-Libre kernel."
msgstr "Intel 32 位架构（IA32)，Linux-Libre 内核。"

msgid "armhf-linux"
msgstr "armhf-linux"

msgid "ARMv7-A architecture with hard float, Thumb-2 and NEON, using the EABI hard-float application binary interface (ABI), and Linux-Libre kernel."
msgstr "ARMv7-A 架构，带硬件浮点数、Thumb-2 和 NEON 扩展，EABI 硬件浮点数应用二进制接口（ABI），和 Linux-Libre 内核。"

msgid "aarch64-linux"
msgstr "aarch64-linux"

msgid "little-endian 64-bit ARMv8-A processors, Linux-Libre kernel."
msgstr "小端序 64 位 ARMv8-A 处理器，Linux-Libre 内核。"

msgid "i586-gnu"
msgstr "i586-gnu"

msgid "powerpc64le-linux"
msgstr "powerpc64le-linux"

msgid "little-endian 64-bit RISC-V processors, specifically RV64GC, and Linux-Libre kernel. This platform is available as a \"technology preview\": although it is supported, substitutes are not yet available from the build farm (@pxref{Substitutes}), and some packages may fail to build (@pxref{Tracking Bugs and Changes}).  That said, the Guix community is actively working on improving this support, and now is a great time to try it and get involved!"
msgstr "小端 64 位 RISC-V 处理器，特别是 RV64GC 和 Linux Libre 内核。该平台可作为“技术预览”使用：尽管支持该平台，但构建场 (@pxref{Substitutes}) 中尚未提供 substitutes，并且某些包可能无法构建 (@pxref{Tracking Bugs and Changes})。这就是说，Guix 社区正在积极完善这种支持，现在是探索和加入它的好时机！"

msgid "With Guix@tie{}System, you @emph{declare} all aspects of the operating system configuration and Guix takes care of instantiating the configuration in a transactional, reproducible, and stateless fashion (@pxref{System Configuration}).  Guix System uses the Linux-libre kernel, the Shepherd initialization system (@pxref{Introduction,,, shepherd, The GNU Shepherd Manual}), the well-known GNU utilities and tool chain, as well as the graphical environment or system services of your choice."
msgstr "在 Guix 系统里，你@emph{声明}操作系统所有方面的配置，然后 Guix 以事务型的，可重复的，和无状态的方式解决实例化配置的问题（@pxref{System Configuration}）。Guix系统使用 Linux-Libre 内核，Shepherd 初始化系统@pxref{Introduction,,, shepherd, GNU Shepherd 用户手册}，知名的 GNU 工具和工具链，以及你可选的图形界面环境和系统服务。"

msgid "Guix System is available on all the above platforms except @code{mips64el-linux}, @code{powerpc-linux}, @code{powerpc64le-linux} and @code{riscv64-linux}."
msgstr "Guix 系统在上面所有的平台上都可用，但@code{mips64el-linux}, @code{powerpc-linux}, @code{powerpc64le-linux} 和 @code{riscv64-linux}除外。"

msgid "For information on porting to other architectures or kernels, @pxref{Porting}."
msgstr "关于移植到其它架构或内核的信息，@pxref{Porting}。"

msgid "Building this distribution is a cooperative effort, and you are invited to join! @xref{Contributing}, for information about how you can help."
msgstr "构建这个发行版需要努力合作，欢迎你加入！关于你可以怎样提供帮助的信息，@xref{Contributing}."

msgid "installing Guix"
msgstr "安装 Guix"

msgid "foreign distro"
msgstr "外部发行版"

msgid "You can install the package management tool Guix on top of an existing GNU/Linux or GNU/Hurd system@footnote{Hurd support is currently limited.}, referred to as a @dfn{foreign distro}.  If, instead, you want to install the complete, standalone GNU system distribution, @dfn{Guix@tie{}System}, @pxref{System Installation}.  This section is concerned only with the installation of Guix on a foreign distro."
msgstr "您可以在现有的 GNU/Linux 或 GNU/Hurd 系统上安装包管理工具 Guix@footnote{Hurd 支持目前有限。}，称为@dfn{外部发行版}。如果您想安装完整的独立 GNU 系统发行版@dfn{Guix@tie{}System}，请参见@ref{System Installation}。本节仅涉及在外部发行版上安装 Guix。"

msgid "This section only applies to systems without Guix.  Following it for existing Guix installations will overwrite important system files."
msgstr "本节仅适用于没有 Guix 的系统。对现有 Guix 安装执行此操作将覆盖重要的系统文件。"

msgid "directories related to foreign distro"
msgstr "和 foreign distro 相关的文件夹"

msgid "When installed on a foreign distro, GNU@tie{}Guix complements the available tools without interference.  Its data lives exclusively in two directories, usually @file{/gnu/store} and @file{/var/guix}; other files on your system, such as @file{/etc}, are left untouched."
msgstr "在 foreign distro 上安装时，GNU@tie{}Guix 可以在不引起冲突的前提下补充现有的工具。它的数据只存放在两个文件夹里，通常是@file{/gnu/store}和@file{/var/guix}；系统上的其它文件，如@file{/etc}，不会被修改。"

msgid "Once installed, Guix can be updated by running @command{guix pull} (@pxref{Invoking guix pull})."
msgstr "一旦安装好了，可以通过运行@command{guix pull}升级 Guix（@pxref{Invoking guix pull})."

msgid "installing Guix from binaries"
msgstr "用二进制文件安装 Guix"

msgid "installer script"
msgstr "安装脚本"

msgid "Setting up the build daemon (@pxref{Setting Up the Daemon})."
msgstr "设置后台进程（@pxref{Setting Up the Daemon}）。"

msgid "substitutes, authorization thereof"
msgstr "substitutes，对其授权"

msgid "The binary installation tarball can be (re)produced and verified simply by running the following command in the Guix source tree:"
msgstr "二进制安装包可以通过在 Guix 源代码树里运行下面这些命令来重现和验证："

msgid "make guix-binary.@var{system}.tar.xz\n"
msgstr "make guix-binary.@var{系统}.tar.xz\n"

msgid "...@: which, in turn, runs:"
msgstr "...@: 这个命令会执行："

msgid ""
"guix pack -s @var{system} --localstatedir \\\n"
"  --profile-name=current-guix guix\n"
msgstr ""
"guix pack -s @var{系统} --localstatedir \\\n"
"  --profile-name=current-guix guix\n"

msgid "@xref{Invoking guix pack}, for more info on this handy tool."
msgstr "@xref{Invoking guix pack}，了解这个方便的工具。"

msgid "./guix-install.sh --uninstall\n"
msgstr "./guix-install.sh --uninstall\n"

msgid "We advise system administrators who install Guix, both from the installation script or @i{via} the native package manager of their foreign distribution, to also regularly read and follow security notices, as shown by @command{guix pull}."
msgstr "我们建议安装 Guix 的系统管理员，无论是通过安装脚本还是通过其外部发行版的本地包管理器，定期阅读和遵循安全通知，如@command{guix pull}所示。"

msgid "daemon"
msgstr "后台进程"

msgid "guix build hello\n"
msgstr "guix build hello\n"

msgid "Operations such as building a package or running the garbage collector are all performed by a specialized process, the build daemon, on behalf of clients.  Only the daemon may access the store and its associated database.  Thus, any operation that manipulates the store goes through the daemon.  For instance, command-line tools such as @command{guix package} and @command{guix build} communicate with the daemon (@i{via} remote procedure calls) to instruct it what to do."
msgstr "构建软件包或运行垃圾回收器之类的操作都是由一个特殊的进程代替客户执行的，即构建后台进程。只有这个进程可以访问仓库和相关的数据库。因此，所有修改仓库的操作都通过这个后台进程执行。例如，@command{guix package}和@command{guix build}之类的命令行工具通过和这个后台进程通信（通过远程过程调用）来指示它该做什么。"

msgid "build environment"
msgstr "构建环境"

msgid "There are currently two ways to set up and run the build daemon:"
msgstr "现在有两种方式设立并运行构建的守护进程："

msgid "running @command{guix-daemon} as ``root'', letting it run build processes as unprivileged users taken from a pool of build users---this is the historical approach;"
msgstr "作为 root 用户运行@command{guix-daemon}，让它指挥一些没有特权的 build 用户来运行负责构建的进程——这是传统方案；"

msgid "running @command{guix-daemon} as a separate unprivileged user, relying on Linux's @dfn{unprivileged user namespace} functionality to set up isolated environments---this is the option chosen when installing Guix on a systemd-based distribution with the installation script (@pxref{Binary Installation})."
msgstr "用一个单独的普通用户运行@command{guix-daemon}，靠 Linux 的@dfn{unprivileged user namespace}功能建立隔离环境——这是用安装脚本在基于 systemd 的发行版上安装Guix 时被采用的选项（@pxref{Binary Installation}）。"

msgid "The sections below describe each of these two configurations in more detail and summarize the kind of build isolation they provide."
msgstr "下面的小节详细描述了这两个配置并总结了它们提供的构建环境的隔离类别。"

msgid "Daemon Running as Root"
msgstr "用 root 用户运行守护进程"

msgid "build users"
msgstr "构建用户"

msgid "On a GNU/Linux system, a build user pool may be created like this (using Bash syntax and the @code{shadow} commands):"
msgstr "在一个 GNU/Linux 系统上，可以这样创建一个构建用户池（用 bash 语法和@code{shadow}命令）："

msgid ""
"# groupadd --system guixbuild\n"
"# for i in $(seq -w 1 10);\n"
"  do\n"
"    useradd -g guixbuild -G guixbuild           \\\n"
"            -d /var/empty -s $(which nologin)   \\\n"
"            -c \"Guix build user $i\" --system    \\\n"
"            guixbuilder$i;\n"
"  done\n"
msgstr ""
"# groupadd --system guixbuild\n"
"# for i in $(seq -w 1 10);\n"
"  do\n"
"    useradd -g guixbuild -G guixbuild           \\\n"
"            -d /var/empty -s $(which nologin)   \\\n"
"            -c \"Guix build user $i\" --system    \\\n"
"            guixbuilder$i;\n"
"  done\n"

msgid "The number of build users determines how many build jobs may run in parallel, as specified by the @option{--max-jobs} option (@pxref{Invoking guix-daemon, @option{--max-jobs}}).  To use @command{guix system vm} and related commands, you may need to add the build users to the @code{kvm} group so they can access @file{/dev/kvm}, using @code{-G guixbuild,kvm} instead of @code{-G guixbuild} (@pxref{Invoking guix system})."
msgstr "构建用户的数量决定了有多少个构建任务可以并行执行，即@option{--max-jobs}参数(@pxref{Invoking guix-daemon, @option{--max-jobs}})。为了使用@command{guix system vm}和相关的命令，你需要把构建用户添加到@code{kvm}用户组，以使它们访问@file{/dev/kvm}。为此，把@code{-G guixbuild}替换成@code{-G guixbuild,kvm}(@pxref{Invoking guix system})."

msgid "# guix-daemon --build-users-group=guixbuild\n"
msgstr "# guix-daemon --build-users-group=guixbuild\n"

msgid "In this setup, @file{/gnu/store} is owned by @code{root}."
msgstr "在这个设定里，@file{/gnu/store}属于@code{root}。"

msgid ""
"# groupadd --system guix-daemon\n"
"# useradd -g guix-daemon -G guix-daemon              \\\n"
"          -d /var/empty -s $(which nologin)          \\\n"
"          -c \"Guix daemon privilege separation user\" \\\n"
"          --system guix-daemon\n"
msgstr ""
"# groupadd --system guix-daemon\n"
"# useradd -g guix-daemon -G guix-daemon              \\\n"
"          -d /var/empty -s $(which nologin)          \\\n"
"          -c \"Guix daemon privilege separation user\" \\\n"
"          --system guix-daemon\n"

msgid ""
"groupadd --system guix-daemon\n"
"useradd -g guix-daemon -G guix-daemon,kvm               \\\n"
"        -d /var/empty -s $(which nologin)               \\\n"
"        -c \"Guix daemon privilege separation user\"      \\\n"
"        --system guix-daemon\n"
"\n"
msgstr ""
"groupadd --system guix-daemon\n"
"useradd -g guix-daemon -G guix-daemon,kvm               \\\n"
"        -d /var/empty -s $(which nologin)               \\\n"
"        -c \"Guix daemon privilege separation user\"      \\\n"
"        --system guix-daemon\n"
"\n"

msgid ""
"# Make the store writable, in case the systemd 'gnu-store.mount'\n"
"# unit made it read-only.\n"
"mount -o remount,rw /gnu/store\n"
"\n"
msgstr ""
"# 若 systemd 的 “gnu-store.mount” 单元将存储区设为只读，则重新挂载为可写。\n"
"mount -o remount,rw /gnu/store\n"
"\n"

msgid ""
"chown -R guix-daemon:guix-daemon                        \\\n"
"  /gnu                                                  \\\n"
"  /var/guix/@{gc.lock,daemon-socket,db,discover@}         \\\n"
"  /var/guix/@{gcroots,offload,substitute,temproots@}      \\\n"
"  /var/log/guix                                         \\\n"
"  /etc/guix\n"
msgstr ""
"chown -R guix-daemon:guix-daemon                        \\\n"
"  /gnu                                                  \\\n"
"  /var/guix/@{gc.lock,daemon-socket,db,discover@}         \\\n"
"  /var/guix/@{gcroots,offload,substitute,temproots@}      \\\n"
"  /var/log/guix                                         \\\n"
"  /etc/guix\n"

msgid ""
"cp /var/guix/profiles/per-user/root/current-guix/lib/systemd/system/*.service \\\n"
"   /etc/systemd/system\n"
"systemctl daemon-reload\n"
"systemctl start guix-daemon\n"
msgstr ""
"cp /var/guix/profiles/per-user/root/current-guix/lib/systemd/system/*.service \\\n"
"   /etc/systemd/system\n"
"systemctl daemon-reload\n"
"systemctl start guix-daemon\n"

msgid ""
"grep User=guix-daemon \\\n"
"  /var/guix/profiles/per-user/root/current-guix/lib/systemd/system/guix-daemon.service\n"
msgstr ""
"grep User=guix-daemon \\\n"
"  /var/guix/profiles/per-user/root/current-guix/lib/systemd/system/guix-daemon.service\n"

msgid "chroot"
msgstr "chroot"

msgid "a minimal @code{/dev} directory, created mostly independently from the host @code{/dev}@footnote{``Mostly'', because while the set of files that appear in the chroot's @code{/dev} is fixed, most of these files can only be created if the host has them.};"
msgstr "一个和主机@code{/dev}独立的@footnote{大致这样，因为虽然 chroot 环境里的@code{/dev}包含的文件是固定的，大部分这些文件只有在主机有对应的文件时才能创建。}，最小的@code{/dev}文件夹；"

msgid "the @code{/proc} directory; it only shows the processes of the container since a separate PID name space is used;"
msgstr "@code{/proc}文件夹；它只含有当前容器的进程，因为用了一个独立的进程 PID 命名空间；"

msgid "@file{/etc/passwd} with an entry for the current user and an entry for user @file{nobody};"
msgstr "@file{/etc/passwd}，仅包含当前用户和@file{nobody}；"

msgid "@file{/etc/group} with an entry for the user's group;"
msgstr "@file{/etc/group}，包含用户的组；"

msgid "@file{/etc/hosts} with an entry that maps @code{localhost} to @code{127.0.0.1};"
msgstr "@file{/etc/hosts}，包含@code{localhost}映射到@code{127.0.0.1}的条目；"

msgid "a writable @file{/tmp} directory."
msgstr "一个可写的@file{/tmp}文件夹。"

msgid "http_proxy"
msgstr "http_proxy"

msgid "Using the Offload Facility"
msgstr "使用任务下发设施"

msgid "offloading"
msgstr "下发"

msgid "build hook"
msgstr "构建钩子"

msgid "The @file{/etc/guix/machines.scm} file typically looks like this:"
msgstr "@file{/etc/guix/machines.scm}文件通常是这样的："

msgid ""
"      (build-machine\n"
"        (name \"armeight.example.org\")\n"
"        (systems (list \"aarch64-linux\"))\n"
"        (host-key \"ssh-rsa AAAAB3Nza@dots{}\")\n"
"        (user \"alice\")\n"
"\n"
msgstr ""
"      (build-machine\n"
"        (name \"armeight.example.org\")\n"
"        (systems (list \"aarch64-linux\"))\n"
"        (host-key \"ssh-rsa AAAAB3Nza@dots{}\")\n"
"        (user \"alice\")\n"
"\n"

msgid "In fact, this file is---not surprisingly!---a Scheme file that is evaluated when the @code{offload} hook is started.  Its return value must be a list of @code{build-machine} objects.  While this example shows a fixed list of build machines, one could imagine, say, using DNS-SD to return a list of potential build machines discovered in the local network (@pxref{Introduction, Guile-Avahi,, guile-avahi, Using Avahi in Guile Scheme Programs}).  The @code{build-machine} data type is detailed below."
msgstr "事实上，这个文件--并不意外地--是一个 Scheme 文件，当@code{下发}钩子被启动时执行。它的返回值必须是一个包含@code{build-machine}对象的列表。虽然这个例子展示的是一个固定的列表，你可以想象，使用 DNS-SD 来返回一个包含从局域网内发现的构建机器的列表，@pxref{Introduction, Guile-Avahi,, guile-avahi, 在 Guile Scheme 程序里使用 Avahi}。@code{build-machine}数据类型的详细信息如下。"

msgid "{Data Type} build-machine"
msgstr "{数据类型} build-machine"

msgid "This data type represents build machines to which the daemon may offload builds.  The important fields are:"
msgstr "这个数据类型表示后台进程可以下发构建任务的构建机器。重要的项有："

msgid "name"
msgstr "name"

msgid "The host name of the remote machine."
msgstr "远程机器的主机名。"

msgid "systems"
msgstr "systems"

msgid "user"
msgstr "user"

msgid "host-key"
msgstr "host-key"

msgid "This must be the machine's SSH @dfn{public host key} in OpenSSH format.  This is used to authenticate the machine when we connect to it.  It is a long string that looks like this:"
msgstr "这必须是机器的 OpenSSH 格式的 SSH@dfn{公钥}。这是用来在连接机器时认证身份的。它是一个像这样的长字符串："

msgid "ssh-ed25519 AAAAC3NzaC@dots{}mde+UhL hint@@example.org\n"
msgstr "ssh-ed25519 AAAAC3NzaC@dots{}mde+UhL hint@@example.org\n"

msgid "If the machine is running the OpenSSH daemon, @command{sshd}, the host key can be found in a file such as @file{/etc/ssh/ssh_host_ed25519_key.pub}."
msgstr "如果这个机器正在运行 OpenSSH 后台进程，@command{sshd}，那么主机公钥可以在@file{/etc/ssh/ssh_host_ed25519_key.pub}找到。"

msgid "A number of optional fields may be specified:"
msgstr "一些可选的项："

msgid "@code{port} (default: @code{22})"
msgstr "@code{port}（默认值：@code{22}）"

msgid "Port number of SSH server on the machine."
msgstr "机器上的 SSH 服务器的端口号。"

msgid "@code{private-key} (default: @file{~root/.ssh/id_rsa})"
msgstr "@code{private-key}（默认值：@file{~root/.ssh/id_rsa}）"

msgid "The SSH private key file to use when connecting to the machine, in OpenSSH format.  This key must not be protected with a passphrase."
msgstr "连接机器时使用的 SSH 私钥，OpenSSH 格式。这个私钥不能被密码保护。"

msgid "Note that the default value is the private key @emph{of the root account}.  Make sure it exists if you use the default."
msgstr "注意，默认值是@emph{root 帐号}的私钥。使用默认值时请确保它存在。"

msgid "@code{compression} (default: @code{\"zlib@@openssh.com,zlib\"})"
msgstr "@code{compression}（默认值：@code{\"zlib@@openssh.com,zlib\"}）"

msgid "@code{compression-level} (default: @code{3})"
msgstr "@code{compression-level}（默认值：@code{3}）"

msgid "The SSH-level compression methods and compression level requested."
msgstr "SSH 压缩算法和压缩级别。"

msgid "Note that offloading relies on SSH compression to reduce bandwidth usage when transferring files to and from build machines."
msgstr "下发任务依赖 SSH 压缩来减少传输文件到构建机器时使用的带宽。"

msgid "@code{daemon-socket} (default: @code{\"/var/guix/daemon-socket/socket\"})"
msgstr "@code{daemon-socket}（默认值：@code{\"/var/guix/daemon-socket/socket\"}）"

msgid "File name of the Unix-domain socket @command{guix-daemon} is listening to on that machine."
msgstr "那台机器上的@command{guix-daemon}监听的 Unix 套接字文件名。"

msgid "@code{parallel-builds} (default: @code{1})"
msgstr "@code{parallel-builds}（默认值：@code{1}）"

msgid "The number of builds that may run in parallel on the machine."
msgstr "那台机器上可以并行运行的构建任务数量。"

msgid "@code{speed} (default: @code{1.0})"
msgstr "@code{speed}（默认值：@code{1.0}）"

msgid "A ``relative speed factor''.  The offload scheduler will tend to prefer machines with a higher speed factor."
msgstr "一个相对的速度值。下发调度器会偏好速度更快的机器。"

msgid "@code{features} (default: @code{'()})"
msgstr "@code{features} （@code{'()}）"

msgid "A list of strings denoting specific features supported by the machine.  An example is @code{\"kvm\"} for machines that have the KVM Linux modules and corresponding hardware support.  Derivations can request features by name, and they will be scheduled on matching build machines."
msgstr "一个表示机器支持的功能的字符串列表。例如，@code{\"kvm\"}表示机器有 KVM Linux 模块和相关的硬件支持。Derivation 可以通过名字请求需要的功能，然后被分发到匹配的机器的任务队列里。"

msgid "The @command{guix} command must be in the search path on the build machines.  You can check whether this is the case by running:"
msgstr "@command{guix}命令必须在构建机器的搜素路径里。你可以通过这个命令检查："

msgid "ssh build-machine guix repl --version\n"
msgstr "ssh build-machine guix repl --version\n"

msgid "There is one last thing to do once @file{machines.scm} is in place.  As explained above, when offloading, files are transferred back and forth between the machine stores.  For this to work, you first need to generate a key pair on each machine to allow the daemon to export signed archives of files from the store (@pxref{Invoking guix archive}):"
msgstr "@file{machines.scm}到位后，还有一件要做的事。如上所述，下发任务时会在机器的仓库之间传输文件。为此，你需要在每台机器上生成一个密钥对，以使后台进程可以从仓库导出签名后的文件包（@pxref{Invoking guix archive}）："

msgid "# guix archive --generate-key\n"
msgstr "# guix archive --generate-key\n"

msgid "Each build machine must authorize the key of the master machine so that it accepts store items it receives from the master:"
msgstr "每台构建机器都必须认证主机器的公钥，从而接收从主机器接收的仓库文件："

msgid "# guix archive --authorize < master-public-key.txt\n"
msgstr "# guix archive --authorize < master-public-key.txt\n"

msgid "Likewise, the master machine must authorize the key of each build machine."
msgstr "类似的，主机器必须认证每台构建机器的公钥："

msgid "All the fuss with keys is here to express pairwise mutual trust relations between the master and the build machines.  Concretely, when the master receives files from a build machine (and @i{vice versa}), its build daemon can make sure they are genuine, have not been tampered with, and that they are signed by an authorized key."
msgstr "所有这些有关公钥的繁琐事宜都是为了表达主服务器和构建服务器之间成对的互相信任关系。具体地，当主机器从构建机器接收文件时（反之亦然），它的构建后台进程可以确保文件是原样的，没有被篡改，并且被认证的公钥签名过。"

msgid "offload test"
msgstr "下发测试"

msgid "To test whether your setup is operational, run this command on the master node:"
msgstr "为了测试你的设置是否能正常工作，在主节点上运行这个命令："

msgid "# guix offload test\n"
msgstr "# guix offload test\n"

msgid "If you want to test a different machine file, just specify it on the command line:"
msgstr "如果你希望用别的文件测试，只需要在命令行指定它："

msgid "# guix offload test machines-qualif.scm\n"
msgstr "# guix offload test machines-qualif.scm\n"

msgid "Last, you can test the subset of the machines whose name matches a regular expression like this:"
msgstr "最后，你可以像这样只测试机器列表里名字匹配某个正则表达式的子集："

msgid "# guix offload test machines.scm '\\.gnu\\.org$'\n"
msgstr "# guix offload test machines.scm '\\.gnu\\.org$'\n"

msgid "offload status"
msgstr "下发状态"

msgid "To display the current load of all build hosts, run this command on the main node:"
msgstr "若想展示所有构建主机的当前负载，在主节点上运行这个命令："

msgid "# guix offload status\n"
msgstr "# guix offload status\n"

msgid "SELinux, daemon policy"
msgstr "SELinux，后台进程策略"

msgid "mandatory access control, SELinux"
msgstr "强制访问控制，SELinux"

msgid "security, guix-daemon"
msgstr "安全，guix-daemon"

msgid "Guix includes an SELinux policy file at @file{etc/guix-daemon.cil} that can be installed on a system where SELinux is enabled, in order to label Guix files and to specify the expected behavior of the daemon.  Since Guix System does not provide an SELinux base policy, the daemon policy cannot be used on Guix System."
msgstr "Guix 附带一个 SELinux 策略文件，位置在@file{etc/guix-daemon.cil}，它可以在启用SELinux 的系统上安装，为 Guix 的文件添加标签及指定后台进程的期望行为。由于 Guix 系统不提供 SELinux 基础策略，这个后台进程策略不能在 Guix 系统上使用。"

msgid "Installing the SELinux policy"
msgstr "安装 SELinux 策略"

msgid "SELinux, policy installation"
msgstr "SELinux，安装策略"

msgid "To install the policy run this command as root:"
msgstr "用 root 用户执行这个命令以安装策略："

msgid "semodule -i /var/guix/profiles/per-user/root/current-guix/share/selinux/guix-daemon.cil\n"
msgstr "semodule -i /var/guix/profiles/per-user/root/current-guix/share/selinux/guix-daemon.cil\n"

msgid ""
"mount -o remount,rw /gnu/store\n"
"restorecon -R /gnu /var/guix\n"
msgstr ""
"mount -o remount,rw /gnu/store\n"
"restorecon -R /gnu /var/guix\n"

msgid "systemctl restart guix-daemon\n"
msgstr "systemctl restart guix-daemon\n"

msgid "Once the policy is installed, the file system has been relabeled, and the daemon has been restarted, it should be running in the @code{guix_daemon_t} context.  You can confirm this with the following command:"
msgstr "一旦安装好策略，为文件系统重新打好标签，并且重启了后台进程，它应该在@code{guix_daemon_t}环境里运行。你可以用下面这个命令确认："

msgid "ps -Zax | grep guix-daemon\n"
msgstr "ps -Zax | grep guix-daemon\n"

msgid "Monitor the SELinux log files as you run a command like @code{guix build hello} to convince yourself that SELinux permits all necessary operations."
msgstr "运行@code{guix build hello}之类的命令并监控 SELinux 日志以说服你自己 SELinux 允许所有的操作。"

msgid "SELinux, limitations"
msgstr "SELinux，限制"

msgid "This policy is not perfect.  Here is a list of limitations or quirks that should be considered when deploying the provided SELinux policy for the Guix daemon."
msgstr "这个策略不是完美的。这里有一个关于限制和缺陷的列表，当为 Guix 后台进程部署提供的 SELinux 策略时该认真考虑。"

msgid "The daemon’s feature to listen for TCP connections might no longer work.  This might require extra rules, because SELinux treats network sockets differently from files."
msgstr "后台进程监听 TCP 连接的功能不再可用。这可能需要额外的规则，因为 SELinux 区别对待网络套接字和文件。"

msgid "Currently all files with a name matching the regular expression @code{/gnu/store/.+-(guix-.+|profile)/bin/guix-daemon} are assigned the label @code{guix_daemon_exec_t}; this means that @emph{any} file with that name in any profile would be permitted to run in the @code{guix_daemon_t} domain.  This is not ideal.  An attacker could build a package that provides this executable and convince a user to install and run it, which lifts it into the @code{guix_daemon_t} domain.  At that point SELinux could not prevent it from accessing files that are allowed for processes in that domain."
msgstr "目前，所有匹配正则表达式@code{/gnu/store/.+-(guix-.+|profile)/bin/guix-daemon}的文件都被赋予@code{guix_daemon_exec_t}标签；这意味着@emph{任何}profile 里的任何有这样名字的的文件都会被允许在@code{guix_daemon_t}域里执行。这不够理想。一个攻击者可以构建提供这个可执行程序的软件包，并说服一个用户安装、运行它，以此进入@code{guix_daemon_t}域。那时，SELinux 无法阻止它访问所在域的进程可以访问的文件。"

msgid "We could generate a much more restrictive policy at installation time, so that only the @emph{exact} file name of the currently installed @code{guix-daemon} executable would be labelled with @code{guix_daemon_exec_t}, instead of using a broad regular expression.  The downside is that root would have to install or upgrade the policy at installation time whenever the Guix package that provides the effectively running @code{guix-daemon} executable is upgraded."
msgstr "我们可以在安装时生成一个更严格的策略，仅当前安装的@code{guix-daemon}的@emph{精确的}的文件名会被打上@code{guix_daemon_exec_t}标签，而不是用一个宽泛的正则表达式。这样的缺点是 root 必须在每次安装提供@code{guix-daemon}的 Guix 软件包时安装或升级策略。"

msgid "Invoking @command{guix-daemon}"
msgstr "调用 @command{guix-daemon}"

msgid "guix-daemon"
msgstr "guix-daemon"

msgid "The @command{guix-daemon} program implements all the functionality to access the store.  This includes launching build processes, running the garbage collector, querying the availability of a build result, etc.  It is normally run as @code{root} like this:"
msgstr "@command{guix-daemon}程序实现了所有访问仓库的功能。包括启动构建进程，运行垃圾回收器，查询构建结果，等。它通常以@code{root}身份运行："

msgid "For details on how to set it up, @pxref{Setting Up the Daemon}."
msgstr "关于如何设置它，@pxref{Setting Up the Daemon}。"

msgid "container, build environment"
msgstr "容器，构建环境"

msgid "reproducible builds"
msgstr "可复现的构建"

msgid "The following command-line options are supported:"
msgstr "下面这些命令行选项受支持："

msgid "--build-users-group=@var{group}"
msgstr "--build-users-group=@var{用户组}"

msgid "Take users from @var{group} to run build processes (@pxref{Setting Up the Daemon, build users})."
msgstr "这会从@var{用户组}里选取用户，以运行构建进程（@pxref{Setting Up the Daemon, 构建用户}）。"

msgid "--no-substitutes"
msgstr "--no-substitutes"

msgid "substitutes"
msgstr "substitutes"

msgid "Do not use substitutes for build products.  That is, always build things locally instead of allowing downloads of pre-built binaries (@pxref{Substitutes})."
msgstr "不要为构建商品使用 substitute。即，总是在本地构建，而不是下载预构建的二进制文件（@pxref{Substitutes}）。"

msgid "When the daemon runs with @option{--no-substitutes}, clients can still explicitly enable substitution @i{via} the @code{set-build-options} remote procedure call (@pxref{The Store})."
msgstr "当后台进程用@code{--no-substitutes}参数启动时，客户端仍然可以显式地通过@code{set-build-options}远程过程调用来启用 substitute（@pxref{The Store}）。"

msgid "daemon-substitute-urls"
msgstr "daemon-substitute-urls"

msgid "--substitute-urls=@var{urls}"
msgstr "--substitute-urls=@var{urls}"

msgid "This means that substitutes may be downloaded from @var{urls}, as long as they are signed by a trusted signature (@pxref{Substitutes})."
msgstr "这意味着可以从@var{urls}下载 substitute，只要它们的签名可信(@pxref{Substitutes})."

msgid "--cache-failures"
msgstr "--cache-failures"

msgid "Cache build failures.  By default, only successful builds are cached."
msgstr "缓存失败的构建。默认地，只缓存成功的构建。"

msgid "When this option is used, @command{guix gc --list-failures} can be used to query the set of store items marked as failed; @command{guix gc --clear-failures} removes store items from the set of cached failures.  @xref{Invoking guix gc}."
msgstr "当这个选项被使用时，可以用@command{guix gc --list-failures}查询被标记为失败的仓库文件；@command{guix gc --clear-failures}从仓库里删除失败的缓存。@xref{Invoking guix gc}."

msgid "--cores=@var{n}"
msgstr "--cores=@var{n}"

msgid "-c @var{n}"
msgstr "-c @var{n}"

msgid "Use @var{n} CPU cores to build each derivation; @code{0} means as many as available."
msgstr "用@var{n}个 CPU 核来构建每个 derivation；@code{0}表示有多少就用多少。"

msgid "--max-jobs=@var{n}"
msgstr "--max-jobs=@var{n}"

msgid "-M @var{n}"
msgstr "-M @var{n}"

msgid "Allow at most @var{n} build jobs in parallel.  The default value is @code{1}.  Setting it to @code{0} means that no builds will be performed locally; instead, the daemon will offload builds (@pxref{Daemon Offload Setup}), or simply fail."
msgstr "最多允许@var{n}个并行的构建任务。默认值是@code{1}。设置为@code{0}表示不在本地执行构建；而是下发构建任务（@pxref{Daemon Offload Setup}），或者直接失败。"

msgid "--max-silent-time=@var{seconds}"
msgstr "--max-silent-time=@var{seconds}"

msgid "When the build or substitution process remains silent for more than @var{seconds}, terminate it and report a build failure."
msgstr "当构建或 substitution 进程超过@var{seconds}秒仍然保持静默，就把它结束掉并报告构建失败。"

msgid "--timeout=@var{seconds}"
msgstr "--timeout=@var{seconds}"

msgid "Likewise, when the build or substitution process lasts for more than @var{seconds}, terminate it and report a build failure."
msgstr "类似地，当构建或 substitution 进程执行超过@var{seconds}秒，就把它结束掉并报告构建失败。"

msgid "--rounds=@var{N}"
msgstr "--rounds=@var{N}"

msgid "Build each derivation @var{n} times in a row, and raise an error if consecutive build results are not bit-for-bit identical.  Note that this setting can be overridden by clients such as @command{guix build} (@pxref{Invoking guix build})."
msgstr "为每个 derivation 构建@var{n}次，如果连续的构建结果不是每个比特都相同就报告错误。这个设置可以被@command{guix build}之类的客户端覆盖（@pxref{Invoking guix build})."

msgid "When used in conjunction with @option{--keep-failed}, the differing output is kept in the store, under @file{/gnu/store/@dots{}-check}.  This makes it easy to look for differences between the two results."
msgstr "当和@option{--keep-failed}一起使用时，不同的输出保存在@file{/gnu/store/@dots{}-check}。这让检查两个结果的区别更容易。"

msgid "--debug"
msgstr "--debug"

msgid "Produce debugging output."
msgstr "生成调试输出。"

msgid "--chroot-directory=@var{dir}"
msgstr "--chroot-directory=@var{dir}"

msgid "Add @var{dir} to the build chroot."
msgstr "把@var{dir}添加到构建的 chroot。"

msgid "Doing this may change the result of build processes---for instance if they use optional dependencies found in @var{dir} when it is available, and not otherwise.  For that reason, it is not recommended to do so.  Instead, make sure that each derivation declares all the inputs that it needs."
msgstr "这么做可能会改变构建进程的结果--例如，如果它们使用了在@var{dir}里发现的可选依赖。因此，建议不要这么做，而是确保每个 derivation 声明所需的全部输入。"

msgid "--disable-chroot"
msgstr "--disable-chroot"

msgid "Disable chroot builds."
msgstr "关闭 chroot 构建。"

msgid "--log-compression=@var{type}"
msgstr "--log-compression=@var{type}"

msgid "Compress build logs according to @var{type}, one of @code{gzip}, @code{bzip2}, or @code{none}."
msgstr "以@var{type}方式压缩构建日志，可选的值：@code{gzip}，@code{bzip2}，@code{none}."

msgid ""
"herd discover guix-daemon on\n"
"herd discover guix-daemon off\n"
msgstr ""
"herd discover guix-daemon on\n"
"herd discover guix-daemon off\n"

msgid "--disable-deduplication"
msgstr "--disable-deduplication"

msgid "deduplication"
msgstr "去重"

msgid "Disable automatic file ``deduplication'' in the store."
msgstr "关闭自动对仓库文件“去重”。"

msgid "By default, files added to the store are automatically ``deduplicated'': if a newly added file is identical to another one found in the store, the daemon makes the new file a hard link to the other file.  This can noticeably reduce disk usage, at the expense of slightly increased input/output load at the end of a build process.  This option disables this optimization."
msgstr "默认地，添加到仓库的文件会被自动“去重”：如果新添加的文件和仓库里找到的某个文件完全相同，后台进程把这个新文件变成另一个文件的硬链接。这可以明显地减少硬盘使用，代价是构建结束后轻微地增加输入／输出负载。这个选项关闭这个优化。"

msgid "--gc-keep-outputs[=yes|no]"
msgstr "--gc-keep-outputs[=yes|no]"

msgid "Tell whether the garbage collector (GC) must keep outputs of live derivations."
msgstr "垃圾收集器（GC）是否必须保留存活的 derivation 的输出。"

msgid "GC roots"
msgstr "GC 根"

msgid "garbage collector roots"
msgstr "垃圾收集的根"

msgid "--gc-keep-derivations[=yes|no]"
msgstr "--gc-keep-derivations[=yes|no]"

msgid "Tell whether the garbage collector (GC) must keep derivations corresponding to live outputs."
msgstr "垃圾收集器（GC）是否必须保留和存活的输出相关的 derivation。"

msgid "--impersonate-linux-2.6"
msgstr "--impersonate-linux-2.6"

msgid "On Linux-based systems, impersonate Linux 2.6.  This means that the kernel's @command{uname} system call will report 2.6 as the release number."
msgstr "在基于 Linux 的系统上，伪装成 Linux 2.6。这意味着内核的@code{uname}系统调用会把版本号报告为 2.6。"

msgid "This might be helpful to build programs that (usually wrongfully) depend on the kernel version number."
msgstr "这可能会有助于构建那些（通常是错误地）依赖内核版本号的程序。"

msgid "--lose-logs"
msgstr "--lose-logs"

msgid "--system=@var{system}"
msgstr "--system=@var{system}"

msgid "Assume @var{system} as the current system type.  By default it is the architecture/kernel pair found at configure time, such as @code{x86_64-linux}."
msgstr "假设@var{system}是当前的系统类型。默认值是 configure 时发现的架构／内核元组，如@code{x86_64-linux}."

msgid "--listen=@var{endpoint}"
msgstr "--listen=@var{endpoint}"

msgid ""
"$ guix install glibc-locales\n"
"$ export GUIX_LOCPATH=$HOME/.guix-profile/lib/locale\n"
msgstr ""
"$ guix install glibc-locales\n"
"$ export GUIX_LOCPATH=$HOME/.guix-profile/lib/locale\n"

msgid ""
"(use-modules (gnu packages base))\n"
"\n"
msgstr ""
"(use-modules (gnu packages base))\n"
"\n"

msgid "X11 Fonts"
msgstr "X11 字体"

msgid ""
"guix install fontconfig\n"
"fc-cache -rv\n"
msgstr ""
"guix install fontconfig\n"
"fc-cache -rv\n"

msgid "guix install font-adobe-source-han-sans:cn\n"
msgstr "guix install font-adobe-source-han-sans:cn\n"

msgid "-*-dejavu sans-medium-r-normal-*-*-100-*-*-*-*-*-1\n"
msgstr "-*-dejavu sans-medium-r-normal-*-*-100-*-*-*-*-*-1\n"

msgid "xset +fp $(dirname $(readlink -f ~/.guix-profile/share/fonts/truetype/fonts.dir))\n"
msgstr "xset +fp $(dirname $(readlink -f ~/.guix-profile/share/fonts/truetype/fonts.dir))\n"

msgid "guix pull\n"
msgstr "guix pull\n"

msgid "sudo -i guix pull\n"
msgstr "sudo -i guix pull\n"

msgid "systemctl restart guix-daemon.service\n"
msgstr "systemctl restart guix-daemon.service\n"

msgid "This section explains how to install Guix System on a machine.  Guix, as a package manager, can also be installed on top of a running GNU/Linux system, @pxref{Installation}."
msgstr "本节介绍如何在机器上安装 Guix 系统。作为软件包管理器，Guix 也可以安装在运行中的 GNU/Linux 系统之上，@pxref{Installation}。"

msgid "We consider Guix System to be ready for a wide range of ``desktop'' and server use cases.  The reliability guarantees it provides---transactional upgrades and rollbacks, reproducibility---make it a solid foundation."
msgstr "我们认为，Guix 系统已为各种“桌面”和服务器用例做好了准备。它提供的可靠性保证——事务性升级和回滚、可重现性——使其成为一个坚实的基础。"

msgid "More and more system services are provided (@pxref{Services})."
msgstr "越来越多的系统服务被提供（@pxref{Services}）。"

msgid "Nevertheless, before you proceed with the installation, be aware that some services you rely on may still be missing from version @value{VERSION}."
msgstr "不过，在继续安装之前，请注意 @value{VERSION} 版本中可能仍然缺少您所依赖的某些服务。"

msgid "More than a disclaimer, this is an invitation to report issues (and success stories!), and to join us in improving it.  @xref{Contributing}, for more info."
msgstr "这不仅是一个免责声明，也是一个报告问题（和成功故事！）的邀请，并与我们一起改进它。请参见 @xref{Contributing} 以获取更多信息。"

msgid "hardware support on Guix System"
msgstr "Guix 系统上的硬件支持"

msgid "GNU@tie{}Guix focuses on respecting the user's computing freedom.  It builds around the kernel Linux-libre, which means that only hardware for which free software drivers and firmware exist is supported.  Nowadays, a wide range of off-the-shelf hardware is supported on GNU/Linux-libre---from keyboards to graphics cards to scanners and Ethernet controllers.  Unfortunately, there are still areas where hardware vendors deny users control over their own computing, and such hardware is not supported on Guix System."
msgstr "GNU@tie{}Guix 注重尊重用户的计算自由。它围绕内核 Linux-libre 构建，这意味着只支持自由软件驱动程序和固件的硬件。如今，GNU/Linux-libre 支持各种现成的硬件――从键盘到显卡，再到扫描仪和以太网控制器。遗憾的是，仍有一些领域的硬件供应商拒绝让用户控制自己的计算机，Guix 系统不支持此类硬件。"

msgid "WiFi, hardware support"
msgstr "WiFi，硬件支持"

msgid "One of the main areas where free drivers or firmware are lacking is WiFi devices.  WiFi devices known to work include those using Atheros chips (AR9271 and AR7010), which corresponds to the @code{ath9k} Linux-libre driver, and those using Broadcom/AirForce chips (BCM43xx with Wireless-Core Revision 5), which corresponds to the @code{b43-open} Linux-libre driver.  Free firmware exists for both and is available out-of-the-box on Guix System, as part of @code{%base-firmware} (@pxref{operating-system Reference, @code{firmware}})."
msgstr "自由驱动程序或固件缺乏的主要领域之一是 WiFi 设备。已知可用的 WiFi 设备包括使用 Atheros 芯片（AR9271 和 AR7010）的设备，这对应于 @code{ath9k} Linux-libre 驱动程序；以及使用 Broadcom/AirForce 芯片（BCM43xx 和 Wireless-Core Revision 5）的设备，这对应于 @code{b43-open} Linux-libre 驱动程序。两者都有自由固件，并作为 @code{%base-firmware} 的一部分在 Guix 系统上开箱即用(@pxref{operating-system Reference, @code{firmware}})."

msgid "The installer warns you early on if it detects devices that are known @emph{not} to work due to the lack of free firmware or free drivers."
msgstr "如果安装程序检测到已知因缺乏自由固件或自由驱动程序而@emph{无法}正常工作的设备，它会提前向您发出警告。"

msgid "RYF, Respects Your Freedom"
msgstr "RYF，尊重您的自由"

msgid "The @uref{https://www.fsf.org/, Free Software Foundation} runs @uref{https://www.fsf.org/ryf, @dfn{Respects Your Freedom}} (RYF), a certification program for hardware products that respect your freedom and your privacy and ensure that you have control over your device.  We encourage you to check the list of RYF-certified devices."
msgstr "@uref{https://www.fsf.org/, 自由软件基金会} 运行 @uref{https://www.fsf.org/ryf, @dfn{Respects Your Freedom}}（RYF，尊重您的自由），这是一项硬件产品认证计划，旨在尊重您的自由和隐私，确保您能控制自己的设备。我们鼓励您查看 RYF 认证设备的列表。"

msgid "Another useful resource is the @uref{https://www.h-node.org/, H-Node} web site.  It contains a catalog of hardware devices with information about their support in GNU/Linux."
msgstr "另一个有用的资源是 @uref{https://www.h-node.org/, H-Node} 网站。它包含了硬件设备的目录，并提供了关于它们在 GNU/Linux 中支持的信息。"

msgid "An ISO-9660 installation image that can be written to a USB stick or burnt to a DVD can be downloaded from @indicateurl{@value{BASE-URL}/guix-system-install-@value{VERSION}.x86_64-linux.iso}, where you can replace @code{x86_64-linux} with one of:"
msgstr "可以从 @indicateurl{@value{BASE-URL}/guix-system-install-@value{VERSION}.x86_64-linux.iso} 下载一个可以写入 USB 闪存驱动器或刻录到 DVD 的 ISO-9660 安装映像，您可以将 @code{x86_64-linux} 替换为以下之一："

msgid "for a GNU/Linux system on Intel/AMD-compatible 64-bit CPUs;"
msgstr "用于在 Intel/AMD 兼容的 64 位 CPU 上运行的 GNU/Linux 系统；"

msgid "for a 32-bit GNU/Linux system on Intel-compatible CPUs."
msgstr "用于在 Intel 兼容 CPU 上运行的 32 位 GNU/Linux 系统。"

msgid "Make sure to download the associated @file{.sig} file and to verify the authenticity of the image against it, along these lines:"
msgstr "确保下载相关的 @file{.sig} 文件，并根据它验证映像的真实性，步骤如下："

msgid ""
"$ wget @value{BASE-URL}/guix-system-install-@value{VERSION}.x86_64-linux.iso.sig\n"
"$ gpg --verify guix-system-install-@value{VERSION}.x86_64-linux.iso.sig\n"
msgstr ""
"$ wget @value{BASE-URL}/guix-system-install-@value{VERSION}.x86_64-linux.iso.sig\n"
"$ gpg --verify guix-system-install-@value{VERSION}.x86_64-linux.iso.sig\n"

msgid "If that command fails because you do not have the required public key, then run this command to import it:"
msgstr "如果那个命令因为缺少所需的公钥而失败了，那么用这个命令导入它："

msgid ""
"$ wget @value{OPENPGP-SIGNING-KEY-URL} \\\n"
"      -qO - | gpg --import -\n"
msgstr ""
"$ wget @value{OPENPGP-SIGNING-KEY-URL} \\\n"
"      -qO - | gpg --import -\n"

msgid "and rerun the @code{gpg --verify} command."
msgstr "再次运行 @code{gpg --verify} 命令。"

msgid "This image contains the tools necessary for an installation.  It is meant to be copied @emph{as is} to a large-enough USB stick or DVD."
msgstr "此映像包含安装所需的工具。它可以@emph{原样}复制到足够大的 U 盘或 DVD 上。"

msgid "Copying to a USB Stick"
msgstr "复制到 USB 闪存驱动器"

msgid "Insert a USB stick of 1@tie{}GiB or more into your machine, and determine its device name.  Assuming that the USB stick is known as @file{/dev/sdX}, copy the image with:"
msgstr "将一个 1@tie{}GiB 或更大的 USB 闪存驱动器插入您的机器，并确定其设备名称。假设 USB 闪存驱动器被称为 @file{/dev/sdX}，可以使用以下命令复制映像："

msgid ""
"dd if=guix-system-install-@value{VERSION}.x86_64-linux.iso of=/dev/sdX status=progress\n"
"sync\n"
msgstr ""
"dd if=guix-system-install-@value{VERSION}.x86_64-linux.iso of=/dev/sdX status=progress\n"
"sync\n"

msgid "Access to @file{/dev/sdX} usually requires root privileges."
msgstr "访问 @file{/dev/sdX} 通常需要 root 权限。"

msgid "Burning on a DVD"
msgstr "刻录到 DVD"

msgid "Insert a blank DVD into your machine, and determine its device name.  Assuming that the DVD drive is known as @file{/dev/srX}, copy the image with:"
msgstr "将一张空白 DVD 插入您的机器，并确定其设备名称。假设 DVD 驱动器被称为 @file{/dev/srX}，可以使用以下命令复制映像："

msgid "growisofs -dvd-compat -Z /dev/srX=guix-system-install-@value{VERSION}.x86_64-linux.iso\n"
msgstr "growisofs -dvd-compat -Z /dev/srX=guix-system-install-@value{VERSION}.x86_64-linux.iso\n"

msgid "Access to @file{/dev/srX} usually requires root privileges."
msgstr "访问 @file{/dev/srX} 通常需要 root 权限。"

msgid "Booting"
msgstr "启动"

msgid "Once this is done, you should be able to reboot the system and boot from the USB stick or DVD@.  The latter usually requires you to get in the BIOS or UEFI boot menu, where you can choose to boot from the USB stick.  In order to boot from Libreboot, switch to the command mode by pressing the @kbd{c} key and type @command{search_grub usb}."
msgstr "完成后，您应该能够重启系统并从 USB 闪存驱动器或 DVD 启动。后者通常需要您进入 BIOS 或 UEFI 启动菜单，在那里您可以选择从 USB 闪存驱动器启动。为了从 Libreboot 启动，请按 @kbd{c} 键切换到命令模式，并输入 @command{search_grub usb}."

msgid "Sadly, on some machines, the installation medium cannot be properly booted and you only see a black screen after booting even after you waited for ten minutes.  This may indicate that your machine cannot run Guix System; perhaps you instead want to install Guix on a foreign distro (@pxref{Binary Installation}).  But don't give up just yet; a possible workaround is pressing the @kbd{e} key in the GRUB boot menu and appending @option{nomodeset} to the Linux bootline.  Sometimes the black screen issue can also be resolved by connecting a different display."
msgstr "遗憾的是，在某些机器上，安装介质无法正确启动，您在启动后只看到黑屏，即使您等待了十分钟。这可能表明您的机器无法运行 Guix 系统；也许您想在其他发行版上安装 Guix (@pxref{Binary Installation})。但不要放弃；一个可能的解决方法是在 GRUB 启动菜单中按 @kbd{e} 键，并将 @option{nomodeset} 附加到 Linux 启动行。有时，黑屏问题也可以通过连接不同的显示器来解决。"

msgid "@xref{Installing Guix in a VM}, if, instead, you would like to install Guix System in a virtual machine (VM)."
msgstr "@xref{Installing Guix in a VM}，如果您希望在虚拟机中安装 Guix 系统。"

msgid "Once you have booted, you can use the guided graphical installer, which makes it easy to get started (@pxref{Guided Graphical Installation}).  Alternatively, if you are already familiar with GNU/Linux and if you want more control than what the graphical installer provides, you can choose the ``manual'' installation process (@pxref{Manual Installation})."
msgstr "一旦您启动后，可以使用向导式图形安装程序，这使入门变得简单 (@pxref{Guided Graphical Installation})。另外，如果您已经熟悉 GNU/Linux，并且希望获得比图形安装程序更多的控制功能，也可以选择``手动''安装程序（@pxref{Manual Installation})."

msgid "The graphical installer is available on TTY1.  You can obtain root shells on TTYs 3 to 6 by hitting @kbd{ctrl-alt-f3}, @kbd{ctrl-alt-f4}, etc.  TTY2 shows this documentation and you can reach it with @kbd{ctrl-alt-f2}.  Documentation is browsable using the Info reader commands (@pxref{Top,,, info-stnd, Stand-alone GNU Info}).  The installation system runs the GPM mouse daemon, which allows you to select text with the left mouse button and to paste it with the middle button."
msgstr "图形安装程序在 TTY1 上可用。您可以通过按 @kbd{ctrl-alt-f3}、@kbd{ctrl-alt-f4} 等在 TTY3 到 TTY6 上获取 root shell。TTY2 显示此文档，您可以通过 @kbd{ctrl-alt-f2} 访问它。文档可以使用 Info 阅读器命令浏览 (@pxref{Top,,, info-stnd, 独立的 GNU Info})。安装系统运行 GPM 鼠标守护进程，允许您使用左键选择文本，并使用中键粘贴。"

msgid "Installation requires access to the Internet so that any missing dependencies of your system configuration can be downloaded.  See the ``Networking'' section below."
msgstr "安装需要访问互联网，以便下载系统配置中缺失的任何依赖项。请参见下面的``网络''部分。"

msgid "The graphical installer is a text-based user interface.  It will guide you, with dialog boxes, through the steps needed to install GNU@tie{}Guix System."
msgstr "图形安装程序是基于文本的用户界面。它将通过对话框引导您完成安装 GNU@tie{}Guix 系统所需的步骤。"

msgid "The first dialog boxes allow you to set up the system as you use it during the installation: you can choose the language, keyboard layout, and set up networking, which will be used during the installation.  The image below shows the networking dialog."
msgstr "第一个对话框允许您在安装过程中设置系统：您可以选择语言、键盘布局，并设置网络，这将在安装过程中使用。下面的图像显示了网络对话框。"

msgid "@image{images/installer-network,5in,, networking setup with the graphical installer}"
msgstr "@image{images/installer-network,5in,, 使用图形安装程序进行网络设置}"

msgid "Later steps allow you to partition your hard disk, as shown in the image below, to choose whether or not to use encrypted file systems, to enter the host name and root password, and to create an additional account, among other things."
msgstr "后续步骤允许您对硬盘进行分区，如下图所示，选择是否使用加密文件系统，输入主机名和 root 密码，以及创建其他帐户等。"

msgid "@image{images/installer-partitions,5in,, partitioning with the graphical installer}"
msgstr "@image{images/installer-partitions,5in,, 使用图形安装程序进行分区}"

msgid "Note that, at any time, the installer allows you to exit the current installation step and resume at a previous step, as show in the image below."
msgstr "请注意，在任何时候，安装程序都允许您退出当前安装步骤并从先前步骤恢复，如下图所示。"

msgid "@image{images/installer-resume,5in,, resuming the installation process}"
msgstr "@image{images/installer-resume,5in,, 恢复安装过程}"

msgid "Once you're done, the installer produces an operating system configuration and displays it (@pxref{Using the Configuration System}).  At that point you can hit ``OK'' and installation will proceed.  On success, you can reboot into the new system and enjoy.  @xref{After System Installation}, for what's next!"
msgstr "完成后，安装程序会生成操作系统配置并显示出来（@pxref{Using the Configuration System}）。此时，您可以点击``确定''，安装将继续。成功后，您可以重启进入新系统并享受。有关接下来的内容，请参见@ref{After System Installation}！"

msgid "This section describes how you would ``manually'' install GNU@tie{}Guix System on your machine.  This option requires familiarity with GNU/Linux, with the shell, and with common administration tools.  If you think this is not for you, consider using the guided graphical installer (@pxref{Guided Graphical Installation})."
msgstr "这个小节描述了如何在你的电脑上``手动地''安装 GNU@tie{}Guix System。这样做需要你熟悉 GNU/Linux，终端以及常用管理工具。若你对此不自信，建议使用向导式图形安装（@pxref{Guided Graphical Installation}）。"

msgid "The installation system provides root shells on TTYs 3 to 6; press @kbd{ctrl-alt-f3}, @kbd{ctrl-alt-f4}, and so on to reach them.  It includes many common tools needed to install the system, but is also a full-blown Guix System.  This means that you can install additional packages, should you need it, using @command{guix package} (@pxref{Invoking guix package})."
msgstr "安装中系统提供 TTY 3 到 6 的 root shell；按@kbd{ctrl-alt-f3}、@kbd{ctrl-alt-f4}即可打开。很多常见的工具都在这个系统内，同时它也是一个完整的 Guix System。这意味着如果需要，使用@command{guix package} (@pxref{Invoking guix package})，你可以下载额外的包。"

msgid "Keyboard Layout, Networking, and Partitioning"
msgstr "键盘布局、网络与分区"

msgid "Before you can install the system, you may want to adjust the keyboard layout, set up networking, and partition your target hard disk.  This section will guide you through this."
msgstr "在您可以安装系统之前，您可能需要调整键盘布局、设置网络和分区目标硬盘。本节将指导您完成这些步骤。"

msgid "keyboard layout"
msgstr "键盘布局"

msgid "The installation image uses the US qwerty keyboard layout.  If you want to change it, you can use the @command{loadkeys} command.  For example, the following command selects the Dvorak keyboard layout:"
msgstr "安装镜像使用的是美式 qwerty 键盘布局，对于中国用户一般无须更改，如果想更改，可以使用 @command{loadkeys} 命令。例如，用以下命令选择 Dvorak 键盘布局："

msgid "loadkeys dvorak\n"
msgstr "loadkeys dvorak\n"

msgid "See the files under @file{/run/current-system/profile/share/keymaps} for a list of available keyboard layouts.  Run @command{man loadkeys} for more information."
msgstr "请查看 @file{/run/current-system/profile/share/keymaps} 下的文件，以获取可用键盘布局的列表。运行 @command{man loadkeys} 以获取更多信息。"

msgid "manual-installation-networking"
msgstr "manual-installation-networking"

msgid "Networking"
msgstr "网络"

msgid "Run the following command to see what your network interfaces are called:"
msgstr "运行以下命令查看你的网络接口的名称："

msgid "ifconfig -a\n"
msgstr "ifconfig -a\n"

msgid "@dots{} or, using the GNU/Linux-specific @command{ip} command:"
msgstr "@dots{} 或者，使用 GNU/Linux 特有的 @command{ip} 命令："

msgid "ip address\n"
msgstr "ip address\n"

msgid "Wired interfaces have a name starting with @samp{e}; for example, the interface corresponding to the first on-board Ethernet controller is called @samp{eno1}.  Wireless interfaces have a name starting with @samp{w}, like @samp{w1p2s0}."
msgstr "有线接口的名称以 @samp{e} 开头；例如，第一块板载以太网控制器对应的接口称为 @samp{eno1}。无线接口的名称以 @samp{w} 开头，如 @samp{w1p2s0}。"

msgid "Wired connection"
msgstr "有线连接"

msgid "To configure a wired network run the following command, substituting @var{interface} with the name of the wired interface you want to use."
msgstr "要配置有线网络，请运行以下命令，将@var{接口名}替换为您要使用的有线接口的名称。"

msgid "ifconfig @var{interface} up\n"
msgstr "ifconfig @var{接口名} up\n"

msgid "ip link set @var{interface} up\n"
msgstr "ip link set @var{接口名} up\n"

msgid "Wireless connection"
msgstr "无线连接"

msgid "wireless"
msgstr "无线"

msgid "WiFi"
msgstr "WiFi"

msgid "To configure wireless networking, you can create a configuration file for the @command{wpa_supplicant} configuration tool (its location is not important) using one of the available text editors such as @command{nano}:"
msgstr "要配置无线网络，您可以使用可用的文本编辑器（如 @command{nano}）为 @command{wpa_supplicant} 配置工具创建一个配置文件（其位置不重要）："

msgid "nano wpa_supplicant.conf\n"
msgstr "nano wpa_supplicant.conf\n"

msgid "As an example, the following stanza can go to this file and will work for many wireless networks, provided you give the actual SSID and passphrase for the network you are connecting to:"
msgstr "作为示例，以下段落可以放入此文件，并且适用于许多无线网络，前提是您提供实际的 SSID 和连接网络的密码："

msgid ""
"network=@{\n"
"  ssid=\"@var{my-ssid}\"\n"
"  key_mgmt=WPA-PSK\n"
"  psk=\"the network's secret passphrase\"\n"
"@}\n"
msgstr ""
"network=@{\n"
"  ssid=\"@var{我的 ssid}\"\n"
"  key_mgmt=WPA-PSK\n"
"  psk=\"网络密码\"\n"
"@}\n"

msgid "Start the wireless service and run it in the background with the following command (substitute @var{interface} with the name of the network interface you want to use):"
msgstr "启动无线服务并使用以下命令在后台运行（将@var{接口名}替换为您要使用的网络接口的名称）："

msgid "wpa_supplicant -c wpa_supplicant.conf -i @var{interface} -B\n"
msgstr "wpa_supplicant -c wpa_supplicant.conf -i @var{接口名} -B\n"

msgid "Run @command{man wpa_supplicant} for more information."
msgstr "运行 @command{man wpa_supplicant} 以获取更多信息。"

msgid "DHCP"
msgstr "DHCP"

msgid "At this point, you need to acquire an IP address.  On a network where IP addresses are automatically assigned @i{via} DHCP, you can run:"
msgstr "此时，您需要获取一个 IP 地址。在一个通过 DHCP 自动分配 IP 地址的网络上，您可以运行："

msgid "dhclient -v @var{interface}\n"
msgstr "dhclient -v @var{接口名}\n"

msgid "Try to ping a server to see if networking is up and running:"
msgstr "尝试 ping 一个服务器以查看网络是否正常运行："

msgid "ping -c 3 gnu.org\n"
msgstr "ping -c 3 gnu.org\n"

msgid "Setting up network access is almost always a requirement because the image does not contain all the software and tools that may be needed."
msgstr "设置网络访问几乎总是必需的，因为映像不包含可能需要的所有软件和工具。"

msgid "proxy, during system installation"
msgstr "代理，在安装系统时"

msgid "If you need HTTP and HTTPS access to go through a proxy, run the following command:"
msgstr "如果您需要通过代理访问 HTTP 和 HTTPS，请运行以下命令："

msgid "herd set-http-proxy guix-daemon @var{URL}\n"
msgstr "herd set-http-proxy guix-daemon @var{URL}\n"

msgid "where @var{URL} is the proxy URL, for example @code{http://example.org:8118}."
msgstr "其中 @var{URL} 是代理 URL，例如 @code{http://example.org:8118}。"

msgid "installing over SSH"
msgstr "通过 SSH 安装"

msgid "If you want to, you can continue the installation remotely by starting an SSH server:"
msgstr "如果您愿意，可以通过启动 SSH 服务器继续远程安装："

msgid "herd start ssh-daemon\n"
msgstr "herd start ssh-daemon\n"

msgid "Make sure to either set a password with @command{passwd}, or configure OpenSSH public key authentication before logging in."
msgstr "确保在登录之前使用 @command{passwd} 设置密码，或配置 OpenSSH 公钥认证。"

msgid "Disk Partitioning"
msgstr "磁盘分区"

msgid "Unless this has already been done, the next step is to partition, and then format the target partition(s)."
msgstr "除非已经完成此操作，否则下一步是对目标分区进行分区，然后格式化。"

msgid "The installation image includes several partitioning tools, including Parted (@pxref{Overview,,, parted, GNU Parted User Manual}), @command{fdisk}, and @command{cfdisk}.  Run it and set up your disk with the partition layout you want:"
msgstr "安装映像包括几个分区工具，包括 Parted (@pxref{Overview,,, parted, GNU Parted User Manual})、@command{fdisk} 和 @command{cfdisk}。运行它并根据您想要的分区布局设置磁盘："

msgid "cfdisk\n"
msgstr "cfdisk\n"

msgid "If your disk uses the GUID Partition Table (GPT) format and you plan to install BIOS-based GRUB (which is the default), make sure a BIOS Boot Partition is available (@pxref{BIOS installation,,, grub, GNU GRUB manual})."
msgstr "如果您的磁盘使用 GUID 分区表（GPT）格式，并且您计划安装基于 BIOS 的 GRUB（这是默认设置），请确保有一个 BIOS 引导分区可用 (@pxref{BIOS installation,,, grub, GNU GRUB manual})."

msgid "EFI, installation"
msgstr "EFI，安装"

msgid "UEFI, installation"
msgstr "UEFI，安装"

msgid "ESP, EFI system partition"
msgstr "ESP，EFI 系统分区"

msgid "If you instead wish to use EFI-based GRUB, a FAT32 @dfn{EFI System Partition} (ESP) is required.  This partition can be mounted at @file{/boot/efi} for instance and must have the @code{esp} flag set.  E.g., for @command{parted}:"
msgstr "如果您希望使用基于 EFI 的 GRUB，则需要一个 FAT32 @dfn{EFI 系统分区}（ESP）。例如，此分区可以挂载在 @file{/boot/efi}，并且必须设置 @code{esp} 标志。例如，对于 @command{parted}："

msgid "parted /dev/sda set 1 esp on\n"
msgstr "parted /dev/sda set 1 esp on\n"

msgid "grub-bootloader"
msgstr "grub-bootloader"

msgid "grub-efi-bootloader"
msgstr "grub-efi-bootloader"

msgid "Unsure whether to use EFI- or BIOS-based GRUB? If the directory @file{/sys/firmware/efi} exists in the installation image, then you should probably perform an EFI installation, using @code{grub-efi-bootloader}.  Otherwise you should use the BIOS-based GRUB, known as @code{grub-bootloader}.  @xref{Bootloader Configuration}, for more info on bootloaders."
msgstr "不确定使用 EFI 还是基于 BIOS 的 GRUB？如果安装映像中存在目录 @file{/sys/firmware/efi}，那么您可能应该执行 EFI 安装，使用 @code{grub-efi-bootloader}。否则，您应该使用基于 BIOS 的 GRUB，称为 @code{grub-bootloader}。有关引导加载器的更多信息，请参见 @xref{Bootloader Configuration}。"

msgid "Once you are done partitioning the target hard disk drive, you have to create a file system on the relevant partition(s)@footnote{Currently Guix System only supports ext4, btrfs, JFS, F2FS, and XFS file systems.  In particular, code that reads file system UUIDs and labels only works for these file system types.}.  For the ESP, if you have one and assuming it is @file{/dev/sda1}, run:"
msgstr "完成目标硬盘驱动器的分区后，您必须在相关分区上创建文件系统@footnote{目前 Guix 系统仅支持 ext4、btrfs、JFS、F2FS 和 XFS 文件系统。特别是，读取文件系统 UUID 和标签的代码仅适用于这些文件系统类型。}。对于 ESP，如果您有一个，并假设它是 @file{/dev/sda1}，请运行："

msgid "mkfs.fat -F32 /dev/sda1\n"
msgstr "mkfs.fat -F32 /dev/sda1\n"

msgid "For the root file system, ext4 is the most widely used format.  Other file systems, such as Btrfs, support compression, which is reported to nicely complement file deduplication that the daemon performs independently of the file system (@pxref{Invoking guix-daemon, deduplication})."
msgstr "对于根文件系统，ext4 是最广泛使用的格式。其他文件系统，如 Btrfs，支持压缩，据报道与守护进程独立于文件系统执行的文件去重很好地互补 (@pxref{Invoking guix-daemon, 去重})。"

msgid "Preferably, assign file systems a label so that you can easily and reliably refer to them in @code{file-system} declarations (@pxref{File Systems}).  This is typically done using the @code{-L} option of @command{mkfs.ext4} and related commands.  So, assuming the target root partition lives at @file{/dev/sda2}, a file system with the label @code{my-root} can be created with:"
msgstr "最好为文件系统分配一个标签，以便您可以在 @code{file-system} 声明中轻松可靠地引用它们 (@pxref{File Systems})。这通常使用 @command{mkfs.ext4} 和相关命令的 @code{-L} 选项来完成。因此，假设目标根分区位于 @file{/dev/sda2}，可以使用以下命令创建标签为 @code{my-root} 的文件系统："

msgid "mkfs.ext4 -L my-root /dev/sda2\n"
msgstr "mkfs.ext4 -L my-root /dev/sda2\n"

msgid "encrypted disk"
msgstr "加密磁盘"

msgid "If you are instead planning to encrypt the root partition, you can use the Cryptsetup/LUKS utilities to do that (see @inlinefmtifelse{html, @uref{https://linux.die.net/man/8/cryptsetup, @code{man cryptsetup}}, @code{man cryptsetup}} for more information)."
msgstr "如果您打算加密根分区，可以使用 Cryptsetup/LUKS 工具来实现（有关更多信息，请参见 @inlinefmtifelse{html, @uref{https://linux.die.net/man/8/cryptsetup, @code{man cryptsetup}}, @code{man cryptsetup}})."

msgid "Assuming you want to store the root partition on @file{/dev/sda2}, the command sequence to format it as a LUKS partition would be along these lines:"
msgstr "假设您想将根分区存储在 @file{/dev/sda2}，将其格式化为 LUKS 分区的命令序列大致如下："

msgid ""
"cryptsetup luksFormat /dev/sda2\n"
"cryptsetup open /dev/sda2 my-partition\n"
"mkfs.ext4 -L my-root /dev/mapper/my-partition\n"
msgstr ""
"cryptsetup luksFormat /dev/sda2\n"
"cryptsetup open /dev/sda2 my-partition\n"
"mkfs.ext4 -L my-root /dev/mapper/my-partition\n"

msgid "Once that is done, mount the target file system under @file{/mnt} with a command like (again, assuming @code{my-root} is the label of the root file system):"
msgstr "完成后，使用类似的命令将目标文件系统挂载到 @file{/mnt} 下（同样，假设 @code{my-root} 是根文件系统的标签）："

msgid "mount LABEL=my-root /mnt\n"
msgstr "mount LABEL=my-root /mnt\n"

msgid "Also mount any other file systems you would like to use on the target system relative to this path.  If you have opted for @file{/boot/efi} as an EFI mount point for example, mount it at @file{/mnt/boot/efi} now so it is found by @code{guix system init} afterwards."
msgstr "还要挂载您希望在目标系统上使用的任何其他文件系统。如果您选择将 @file{/boot/efi} 作为 EFI 挂载点，请现在将其挂载到 @file{/mnt/boot/efi}，以便之后被 @code{guix system init} 找到。"

msgid "Finally, if you plan to use one or more swap partitions (@pxref{Swap Space}), make sure to initialize them with @command{mkswap}.  Assuming you have one swap partition on @file{/dev/sda3}, you would run:"
msgstr "最后，如果您计划使用一个或多个交换分区（@pxref{Swap Space}），请确保使用 @command{mkswap} 初始化它们。假设您在 @file{/dev/sda3} 上有一个交换分区，您可以运行："

msgid ""
"mkswap /dev/sda3\n"
"swapon /dev/sda3\n"
msgstr ""
"mkswap /dev/sda3\n"
"swapon /dev/sda3\n"

msgid "Alternatively, you may use a swap file.  For example, assuming that in the new system you want to use the file @file{/swapfile} as a swap file, you would run@footnote{This example will work for many types of file systems (e.g., ext4).  However, for copy-on-write file systems (e.g., btrfs), the required steps may be different.  For details, see the manual pages for @command{mkswap} and @command{swapon}.}:"
msgstr "另外，您可以使用交换文件。例如，假设在新系统中您想将文件 @file{/swapfile} 用作交换文件，您可以运行@footnote{此示例适用于许多类型的文件系统（例如，ext4）。但是，对于写时复制文件系统（例如，btrfs），所需的步骤可能会有所不同。有关详细信息，请参阅 @command{mkswap} 和 @command{swapon} 的手册页。}："

msgid ""
"# This is 10 GiB of swap space.  Adjust \"count\" to change the size.\n"
"dd if=/dev/zero of=/mnt/swapfile bs=1MiB count=10240\n"
"# For security, make the file readable and writable only by root.\n"
"chmod 600 /mnt/swapfile\n"
"mkswap /mnt/swapfile\n"
"swapon /mnt/swapfile\n"
msgstr ""
"# 这是 10 GiB 的交换空间。调整“count”以更改大小。\n"
"dd if=/dev/zero of=/mnt/swapfile bs=1MiB count=10240\n"
"# 为了安全起见，使文件仅对 root 可读和可写。\n"
"chmod 600 /mnt/swapfile\n"
"mkswap /mnt/swapfile\n"
"swapon /mnt/swapfile\n"

msgid "Note that if you have encrypted the root partition and created a swap file in its file system as described above, then the encryption also protects the swap file, just like any other file in that file system."
msgstr "请注意，如果您加密了根分区并在其文件系统中创建了交换文件，如上所述，那么加密也会保护交换文件，就像该文件系统中的任何其他文件一样。"

msgid "With the target partitions ready and the target root mounted on @file{/mnt}, we're ready to go.  First, run:"
msgstr "目标分区准备就绪，目标根目录挂载在 @file{/mnt} 上，我们准备好了。首先，运行："

msgid "herd start cow-store /mnt\n"
msgstr "herd start cow-store /mnt\n"

msgid "This makes @file{/gnu/store} copy-on-write, such that packages added to it during the installation phase are written to the target disk on @file{/mnt} rather than kept in memory.  This is necessary because the first phase of the @command{guix system init} command (see below) entails downloads or builds to @file{/gnu/store} which, initially, is an in-memory file system."
msgstr "这使得 @file{/gnu/store} 写时复制，这使得在下载阶段添加的包会被写入到 /mnt 挂载的硬盘上，而非将其保存在内存里。这是必要的，因为 @command{guix system init} 命令（见下）的第一阶段要求下载和编译在 @file{/gnu/store} 进行，而这个文件系统初始是在内存里。"

msgid "@xref{Using the Configuration System}, for an overview of the configuration file.  The example configurations discussed in that section are available under @file{/etc/configuration} in the installation image.  Thus, to get started with a system configuration providing a graphical display server (a ``desktop'' system), you can run something along these lines:"
msgstr "@xref{Using the Configuration System}，即为配置文件的概述。该小节讨论的示例配置可以在安装映像的@file{/etc/configuration}下找到。因此，若要开始使用为显示图形的服务器（一个“桌面的”系统）提供的系统配置，您可以运行参考以下内容的命令："

msgid ""
"# mkdir /mnt/etc\n"
"# cp /etc/configuration/desktop.scm /mnt/etc/config.scm\n"
"# nano /mnt/etc/config.scm\n"
msgstr ""
"# mkdir /mnt/etc\n"
"# cp /etc/configuration/desktop.scm /mnt/etc/config.scm\n"
"# nano /mnt/etc/config.scm\n"

msgid "guix system init /mnt/etc/config.scm /mnt\n"
msgstr "guix system init /mnt/etc/config.scm /mnt\n"

msgid ""
"guix pull\n"
"sudo guix system reconfigure /etc/config.scm\n"
msgstr ""
"guix pull\n"
"sudo guix system reconfigure /etc/config.scm\n"

msgid "Installing Guix in a Virtual Machine"
msgstr "在虚拟机中安装 Guix"

msgid "qemu-img create -f qcow2 guix-system.img 50G\n"
msgstr "qemu-img create -f qcow2 guix-system.img 50G\n"

msgid ""
"qemu-system-x86_64 -m 1024 -smp 1 -enable-kvm \\\n"
"  -nic user,model=virtio-net-pci -boot menu=on,order=d \\\n"
"  -drive file=guix-system.img \\\n"
"  -drive media=cdrom,readonly=on,file=guix-system-install-@value{VERSION}.@var{system}.iso\n"
msgstr ""
"qemu-system-x86_64 -m 1024 -smp 1 -enable-kvm \\\n"
"  -nic user,model=virtio-net-pci -boot menu=on,order=d \\\n"
"  -drive file=guix-system.img \\\n"
"  -drive media=cdrom,readonly=on,file=guix-system-install-@value{VERSION}.@var{系统}.iso\n"

msgid "guix system image -t iso9660 gnu/system/install.scm\n"
msgstr "guix system image -t iso9660 gnu/system/install.scm\n"

msgid "guix system image --system=armhf-linux -e '((@@ (gnu system install) os-with-u-boot) (@@ (gnu system install) installation-os) \"A20-OLinuXino-Lime2\")'\n"
msgstr "guix system image --system=armhf-linux -e '((@@ (gnu system install) os-with-u-boot) (@@ (gnu system install) installation-os) \"A20-OLinuXino-Lime2\")'\n"

msgid "guix search text editor\n"
msgstr "guix search text editor\n"

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

msgid ""
"hint: Consider setting the necessary environment variables by running:\n"
"\n"
msgstr ""
"考虑通过运行以下命令设置必要的环境变量：\n"
"\n"

msgid ""
"     GUIX_PROFILE=\"$HOME/.guix-profile\"\n"
"     . \"$GUIX_PROFILE/etc/profile\"\n"
"\n"
msgstr ""
"     GUIX_PROFILE=\"$HOME/.guix-profile\"\n"
"     . \"$GUIX_PROFILE/etc/profile\"\n"
"\n"

msgid "Alternately, see `guix package --search-paths -p \"$HOME/.guix-profile\"'.\n"
msgstr "或者，参见 `guix package --search-paths -p \"$HOME/.guix-profile\"'。\n"

msgid "guix package --list-installed\n"
msgstr "guix package --list-installed\n"

msgid "guix package --roll-back\n"
msgstr "guix package --roll-back\n"

msgid "guix package --list-generations\n"
msgstr "guix package --list-generations\n"

msgid "Now you know the basics of package management!"
msgstr "现在你知道包管理的基本知识了吧！"

msgid ""
"GUIX_PROFILE=\"$HOME/.config/guix/current\"\n"
". \"$GUIX_PROFILE/etc/profile\"\n"
msgstr ""
"GUIX_PROFILE=\"$HOME/.config/guix/current\"\n"
". \"$GUIX_PROFILE/etc/profile\"\n"

msgid "hash guix\n"
msgstr "hash guix\n"

msgid "guix upgrade\n"
msgstr "guix upgrade\n"

msgid "guix describe\n"
msgstr "guix describe\n"

msgid "sudo guix system reconfigure /etc/config.scm\n"
msgstr "sudo guix system reconfigure /etc/config.scm\n"

msgid "Resources"
msgstr "资源"

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

msgid "Here we assume you've already made your first steps with Guix (@pxref{Getting Started}) and would like to get an overview about what's going on under the hood."
msgstr "本节假设您已完成 Guix 的初步使用（@pxref{入门}），并希望深入了解其底层实现原理。"

msgid "When using Guix, each package ends up in the @dfn{package store}, in its own directory---something that resembles @file{/gnu/store/xxx-package-1.2}, where @code{xxx} is a base32 string."
msgstr "使用 Guix 时，每个软件包最终将存于@dfn{软件包存储区}中，拥有独立目录——其路径形如 @file{/gnu/store/xxx-package-1.2}，其中 @code{xxx} 为 Base32 字符串。"

msgid "Instead of referring to these directories, users have their own @dfn{profile}, which points to the packages that they actually want to use.  These profiles are stored within each user's home directory, at @code{$HOME/.guix-profile}."
msgstr "用户无需直接引用这些目录路径，而是通过专属@dfn{软件集}管理实际使用的软件包。这些软件集存储于各用户家目录下的 @code{$HOME/.guix-profile} 路径中。"

msgid "For example, @code{alice} installs GCC 4.7.2.  As a result, @file{/home/alice/.guix-profile/bin/gcc} points to @file{/gnu/store/@dots{}-gcc-4.7.2/bin/gcc}.  Now, on the same machine, @code{bob} had already installed GCC 4.8.0.  The profile of @code{bob} simply continues to point to @file{/gnu/store/@dots{}-gcc-4.8.0/bin/gcc}---i.e., both versions of GCC coexist on the same system without any interference."
msgstr "例如，@emph{李华}安装了 GCC 4.7.2 后，@file{/home/LiHua/.guix-profile/bin/gcc} 将指向 @file{/gnu/store/@dots{}-gcc-4.7.2/bin/gcc}。而同一台机器上，@emph{李明}已安装的 GCC 4.8.0 对应的软件集仍指向 @file{/gnu/store/@dots{}-gcc-4.8.0/bin/gcc}——两版 GCC 在系统中互不干扰地共存。"

msgid "The @command{guix package} command is the central tool to manage packages (@pxref{Invoking guix package}).  It operates on the per-user profiles, and can be used @emph{with normal user privileges}."
msgstr "@command{guix package} 是管理软件包的核心工具（@pxref{调用 guix package}）。该命令操作用户专属的软件集，且@emph{支持普通用户权限执行}。"

msgid "transactions"
msgstr "事务"

msgid "The command provides the obvious install, remove, and upgrade operations.  Each invocation is actually a @emph{transaction}: either the specified operation succeeds, or nothing happens.  Thus, if the @command{guix package} process is terminated during the transaction, or if a power outage occurs during the transaction, then the user's profile remains in its previous state, and remains usable."
msgstr "此命令提供基础的安装、移除与升级操作。每次调用均为原子@emph{事务}：要么完整执行指定操作，要么维持原状。因此，若 @command{guix package} 进程在事务中意外终止，或遭遇断电故障，用户软件集仍将保持先前可用状态。"

msgid "In addition, any package transaction may be @emph{rolled back}.  So, if, for example, an upgrade installs a new version of a package that turns out to have a serious bug, users may roll back to the previous instance of their profile, which was known to work well.  Similarly, the global system configuration on Guix is subject to transactional upgrades and roll-back (@pxref{Getting Started with the System})."
msgstr "此外，任何软件包事务均可@emph{回滚}。例如：当升级安装的新版软件包存在严重缺陷时，用户可回滚至已知稳定的历史软件集版本。类似地，Guix 的全局系统配置同样支持事务式升级与回滚（@pxref{Getting Started with the System}）。"

msgid "All packages in the package store may be @emph{garbage-collected}.  Guix can determine which packages are still referenced by user profiles, and remove those that are provably no longer referenced (@pxref{Invoking guix gc}).  Users may also explicitly remove old generations of their profile so that the packages they refer to can be collected."
msgstr "软件包存储区中的所有软件均可进行@emph{垃圾回收}。Guix 能识别仍被用户软件集引用的软件包，并移除可证明未被引用的软件（@pxref{Invoking guix gc}）。用户亦可显式删除历史软件集代，使其引用的软件包可被回收。"

msgid "Guix takes a @dfn{purely functional} approach to package management, as described in the introduction (@pxref{Introduction}).  Each @file{/gnu/store} package directory name contains a hash of all the inputs that were used to build that package---compiler, libraries, build scripts, etc.  This direct correspondence allows users to make sure a given package installation matches the current state of their distribution.  It also helps maximize @dfn{build reproducibility}: thanks to the isolated build environments that are used, a given build is likely to yield bit-identical files when performed on different machines (@pxref{Invoking guix-daemon, container})."
msgstr "Guix 采用@dfn{纯函数式}包管理范式（详见导论参见@ref{Introduction}）。每个 @file{/gnu/store} 软件包目录名包含构建该软件所有输入的哈希值——编译器、库、构建脚本等。这种直接对应关系确保软件包安装状态与系统当前分布一致，同时最大化提升@dfn{构建可复现性}：依托隔离构建环境，相同构建在不同设备上可生成比特级一致文件（@pxref{Invoking guix-daemon, container}）。"

msgid "This foundation allows Guix to support @dfn{transparent binary/source deployment}.  When a pre-built binary for a @file{/gnu/store} item is available from an external source---a @dfn{substitute}, Guix just downloads it and unpacks it; otherwise, it builds the package from source, locally (@pxref{Substitutes}).  Because build results are usually bit-for-bit reproducible, users do not have to trust servers that provide substitutes: they can force a local build and @emph{challenge} providers (@pxref{Invoking guix challenge})."
msgstr "此基础架构支持@dfn{透明的二进制/源码混合部署}。当 @file{/gnu/store} 项存在预编译二进制@dfn{替代品}时，Guix 直接下载解压；否则执行本地源码构建（@pxref{Substitutes}）。因构建结果通常具备比特级可复现性，用户无需信任替代源服务器：可强制本地构建并@emph{验证}@footnote{原文为 “challenge”，意为挑战。}提供者结果（@pxref{Invoking guix challenge}）。"

msgid "Control over the build environment is a feature that is also useful for developers.  The @command{guix shell} command allows developers of a package to quickly set up the right development environment for their package, without having to manually install the dependencies of the package into their profile (@pxref{Invoking guix shell})."
msgstr "对构建环境的精准控制同样惠及开发者。@command{guix shell} 命令使软件包开发者能快速搭建专属开发环境，无需手动安装依赖至个人软件集（@pxref{Invoking guix shell}）。"

msgid "replication, of software environments"
msgstr "软件环境复现"

msgid "provenance tracking, of software artifacts"
msgstr "制品来源追踪"

msgid "All of Guix and its package definitions is version-controlled, and @command{guix pull} allows you to ``travel in time'' on the history of Guix itself (@pxref{Invoking guix pull}).  This makes it possible to replicate a Guix instance on a different machine or at a later point in time, which in turn allows you to @emph{replicate complete software environments}, while retaining precise @dfn{provenance tracking} of the software."
msgstr ""
"Guix 及其所有软件包定义均受版本控制，通过 @command{guix pull} 命令可在 Guix 自身的历史版本中进行“时间旅行”（@pxref{Invoking guix pull}）。这使您能够在不同设备或未来时间点复现相同的 Guix 实例，进而实现 @emph{完整软件环境的精准复现}，同时保持精确的软件 @dfn{来源追踪}。\n"
"\n"
"@unnumberedsec 关于“软件集”译法的说明\n"
"\n"
"亲爱的读者，本书将 Guix 核心概念“profile”统一译为@dfn{软件集}，特此说明：\n"
"\n"
"该术语本质是@emph{由符号链接动态组成的软件环境容器}（如用户默认的 @file{~/.guix-profile}），其核心价值在于提供@emph{环境隔离、原子更新与精确复现}能力。我们选择“软件集”译法主要考量术语简洁性（三字）与认知普适性，但需坦诚此译法存在两点折损：1) 未充分体现“动态链接”物理本质；2) 弱化了“环境隔离”的功能维度。\n"
"\n"
"其他候选译法中，“配置文件”易与传统配置混淆，“环境配置集”过于冗长，“境链”虽精准但属新造词需额外解释。为保障行文连贯性不得已择此译法，对未能完全传递概念精妙之处深表歉意，恳请读者通过上下文理解其@emph{链接集合}与@emph{环境容器}双重属性。\n"
"\n"
"若有优化建议，敬请反馈翻译团队。"

msgid "Invoking @command{guix package}"
msgstr "调用 @command{guix package}"

msgid "installing packages"
msgstr "安装软件包"

msgid "removing packages"
msgstr "移除软件包"

msgid "package installation"
msgstr "软件包安装"

msgid "package removal"
msgstr "软件包移除"

msgid "guix package"
msgstr "guix package"

msgid "The @command{guix package} command is the tool that allows users to install, upgrade, and remove packages, as well as rolling back to previous configurations.  These operations work on a user @dfn{profile}---a directory of installed packages.  Each user has a default profile in @file{$HOME/.guix-profile}.  The command operates only on the user's own profile, and works with normal user privileges (@pxref{Features}).  Its syntax is:"
msgstr "@command{guix package} 命令支持用户安装、升级、移除软件包及回滚至历史配置。这些操作作用于用户专属的@dfn{软件集}——即已安装软件包的目录。每位用户的默认软件集位于 @file{$HOME/.guix-profile}，该命令仅操作用户自身软件集，且以普通用户权限运行（@pxref{功能}）。其基本语法为："

msgid "guix package @var{options}\n"
msgstr "guix package @var{选项}\n"

msgid "Primarily, @var{options} specifies the operations to be performed during the transaction.  Upon completion, a new profile is created, but previous @dfn{generations} of the profile remain available, should the user want to roll back."
msgstr "核心功能在于，@var{选项}指定事务处理期间执行的操作。完成后将创建新的软件集，而旧有软件集的@dfn{代}仍可访问——若用户需要执行回滚操作。"

msgid "For example, to remove @code{lua} and install @code{guile} and @code{guile-cairo} in a single transaction:"
msgstr "例如，通过单次事务处理同时移除 @code{lua} 并安装 @code{guile} 与 @code{guile-cairo}："

msgid "guix package -r lua -i guile guile-cairo\n"
msgstr "guix package -r lua -i guile guile-cairo\n"

msgid "aliases, for @command{guix package}"
msgstr "@command{guix package} 的别名"

msgid "For your convenience, we also provide the following aliases:"
msgstr "为提升操作便捷性，系统提供以下等效别名："

msgid "@command{guix search} is an alias for @command{guix package -s},"
msgstr "@command{guix search} 等效于 @command{guix package -s}，"

msgid "@command{guix install} is an alias for @command{guix package -i},"
msgstr "@command{guix install} 等效于 @command{guix package -i}，"

msgid "@command{guix remove} is an alias for @command{guix package -r},"
msgstr "@command{guix remove} 等效于 @command{guix package -r}，"

msgid "@command{guix upgrade} is an alias for @command{guix package -u},"
msgstr "@command{guix upgrade} 等效于 @command{guix package -u}，"

msgid "and @command{guix show} is an alias for @command{guix package --show=}."
msgstr "@command{guix show} 等效于 @command{guix package --show=}。"

msgid "These aliases are less expressive than @command{guix package} and provide fewer options, so in some cases you'll probably want to use @command{guix package} directly."
msgstr "这些别名的功能丰富性不及 @command{guix package} 且选项较少，故某些场景建议直接使用 @command{guix package}。"

msgid "@command{guix package} also supports a @dfn{declarative approach} whereby the user specifies the exact set of packages to be available and passes it @i{via} the @option{--manifest} option (@pxref{profile-manifest, @option{--manifest}})."
msgstr "@command{guix package} 同时支持@dfn{声明式配置方案}：用户可指定精确的软件包集合，并通过 @option{--manifest} 选项触发配置（@pxref{profile-manifest, @option{--manifest}}）。"

msgid "For each user, a symlink to the user's default profile is automatically created in @file{$HOME/.guix-profile}.  This symlink always points to the current generation of the user's default profile.  Thus, users can add @file{$HOME/.guix-profile/bin} to their @env{PATH} environment variable, and so on."
msgstr "系统在用户家目录下的 @file{$HOME/.guix-profile} 路径自动创建指向其默认软件集的符号链接。该链接始终指向当前软件集的最新代。用户因而可将 @file{$HOME/.guix-profile/bin} 加入 @env{PATH} 环境变量等设置中。"

msgid "search paths"
msgstr "搜索路径"

msgid "If you are not using Guix System, consider adding the following lines to your @file{~/.bash_profile} (@pxref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}) so that newly-spawned shells get all the right environment variable definitions:"
msgstr "若您未使用 Guix 系统，建议将以下配置添加至 @file{~/.bash_profile}（@pxref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}），以确保新启动的 Shell 进程自动载入正确的环境变量："

msgid ""
"GUIX_PROFILE=\"$HOME/.guix-profile\" ; \\\n"
"source \"$GUIX_PROFILE/etc/profile\"\n"
msgstr ""
"GUIX_PROFILE=\"$HOME/.guix-profile\" ; \\\n"
"source \"$GUIX_PROFILE/etc/profile\"\n"

msgid "In a multi-user setup, user profiles are stored in a place registered as a @dfn{garbage-collector root}, which @file{$HOME/.guix-profile} points to (@pxref{Invoking guix gc}).  That directory is normally @code{@var{localstatedir}/guix/profiles/per-user/@var{user}}, where @var{localstatedir} is the value passed to @code{configure} as @option{--localstatedir}, and @var{user} is the user name.  The @file{per-user} directory is created when @command{guix-daemon} is started, and the @var{user} sub-directory is created by @command{guix package}."
msgstr "在多用户配置中，用户软件集存储于注册为 @dfn{垃圾回收根目录} 的位置（@file{$HOME/.guix-profile} 指向该位置，@pxref{Invoking guix gc}）。该目录通常为 @code{@var{localstatedir}/guix/profiles/per-user/@var{user}}，其中 @var{localstatedir} 是通过 @option{--localstatedir} 传递给 @command{configure} 的值，@var{user} 为用户名。@file{per-user} 目录在启动 @command{guix-daemon} 时创建，而 @var{user} 子目录由 @command{guix package} 命令生成。"

msgid "The @var{options} can be among the following:"
msgstr "@var{options} 可以是以下选项之一："

msgid "--install=@var{package} @dots{}"
msgstr "--install=@var{软件包} @dots{}"

msgid "-i @var{package} @dots{}"
msgstr "-i @var{软件包} @dots{}"

msgid "Install the specified @var{package}s."
msgstr "安装指定@var{软件包}。"

msgid "Each @var{package} may specify a simple package name, such as @code{guile}, optionally followed by an at-sign and version number, such as @code{guile@@3.0.7} or simply @code{guile@@3.0}.  In the latter case, the newest version prefixed by @code{3.0} is selected."
msgstr "每个@var{软件包}标识符可采用基础命名格式（如 @code{guile}），或追加 @ 符号及版本号（如 @code{guile@@3.0.7} 或 @code{guile@@3.0}）。后者将自动选择前缀为 @code{3.0} 的最新版本。"

msgid "If no version number is specified, the newest available version will be selected.  In addition, such a @var{package} specification may contain a colon, followed by the name of one of the outputs of the package, as in @code{gcc:doc} or @code{binutils@@2.22:lib} (@pxref{Packages with Multiple Outputs})."
msgstr "若未指定版本号，系统将自动选择最新可用版本。此外，此类@var{软件包}标识符可包含冒号以指定软件包的特定输出，例如 @code{gcc:doc} 或 @code{binutils@@2.22:lib}（@pxref{Packages with Multiple Outputs}）。"

msgid "Packages with a corresponding name (and optionally version) are searched for among the GNU distribution modules (@pxref{Package Modules})."
msgstr "在 GNU 发行版模块中搜索符合指定名称（及可选版本号）的软件包（@pxref{Package Modules}）。"

msgid "@verbatiminclude package-hello.json\n"
msgstr "@verbatiminclude package-hello.json\n"

msgid "guix install emacs-next --with-branch=emacs-next=master\n"
msgstr "guix install emacs-next --with-branch=emacs-next=master\n"

msgid "guix install @var{package}\n"
msgstr "guix install @var{package}\n"

msgid "$ guix package --upgrade . --do-not-upgrade emacs\n"
msgstr "$ guix package --upgrade . --do-not-upgrade emacs\n"

msgid "profile-manifest"
msgstr "profile-manifest"

msgid "$ eval $(guix package --search-paths)\n"
msgstr "$ eval $(guix package --search-paths)\n"

msgid ""
"$ guix package -p foo -i guile\n"
"$ guix package -p bar -i guile-json\n"
"$ guix package -p foo -p bar --search-paths\n"
msgstr ""
"$ guix package -p foo -i guile\n"
"$ guix package -p bar -i guile-json\n"
"$ guix package -p foo -p bar --search-paths\n"

msgid ""
"$ guix install hello -p ~/code/my-profile\n"
"@dots{}\n"
"$ ~/code/my-profile/bin/hello\n"
"Hello, world!\n"
msgstr ""
"$ guix install hello -p ~/code/my-profile\n"
"@dots{}\n"
"$ ~/code/my-profile/bin/hello\n"
"世界你好！\n"

msgid "$ rm ~/code/my-profile ~/code/my-profile-*-link\n"
msgstr "$ rm ~/code/my-profile ~/code/my-profile-*-link\n"

msgid ""
"$ guix package --list-profiles\n"
"/home/charlie/.guix-profile\n"
"/home/charlie/code/my-profile\n"
"/home/charlie/code/devel-profile\n"
"/home/charlie/tmp/test\n"
msgstr ""
"$ guix package --list-profiles\n"
"/home/charlie/.guix-profile\n"
"/home/charlie/code/my-profile\n"
"/home/charlie/code/devel-profile\n"
"/home/charlie/tmp/test\n"

msgid ""
"$ guix package -s malloc | recsel -p name,version,relevance\n"
"name: jemalloc\n"
"version: 4.5.0\n"
"relevance: 6\n"
"\n"
msgstr ""
"$ guix package -s malloc | recsel -p name,version,relevance\n"
"name: jemalloc\n"
"version: 4.5.0\n"
"relevance: 6\n"
"\n"

msgid ""
"name: glibc\n"
"version: 2.25\n"
"relevance: 1\n"
"\n"
msgstr ""
"name: glibc\n"
"version: 2.25\n"
"relevance: 1\n"
"\n"

msgid ""
"name: libgc\n"
"version: 7.6.0\n"
"relevance: 1\n"
msgstr ""
"name: libgc\n"
"version: 7.6.0\n"
"relevance: 1\n"

msgid ""
"$ guix package -s \"\" | recsel -p name -e 'license ~ \"LGPL 3\"'\n"
"name: elfutils\n"
"\n"
msgstr ""
"$ guix package -s \"\" | recsel -p name -e 'license ~ \"LGPL 3\"'\n"
"name: elfutils\n"
"\n"

msgid ""
"name: gmp\n"
"@dots{}\n"
msgstr ""
"name: gmp\n"
"@dots{}\n"

msgid ""
"$ guix search '\\<board\\>' game | recsel -p name\n"
"name: gnubg\n"
"@dots{}\n"
msgstr ""
"$ guix search '\\<board\\>' game | recsel -p name\n"
"name: gnubg\n"
"@dots{}\n"

msgid ""
"$ guix search crypto library | \\\n"
"    recsel -e '! (name ~ \"^(ghc|perl|python|ruby)\")' -p name,synopsis\n"
msgstr ""
"$ guix search crypto library | \\\n"
"    recsel -e '! (name ~ \"^(ghc|perl|python|ruby)\")' -p name,synopsis\n"

msgid ""
"$ guix package --show=guile | recsel -p name,version\n"
"name: guile\n"
"version: 3.0.5\n"
"\n"
msgstr ""
"$ guix package --show=guile | recsel -p name,version\n"
"name: guile\n"
"version: 3.0.5\n"
"\n"

msgid ""
"name: guile\n"
"version: 3.0.2\n"
"\n"
msgstr ""
"name: guile\n"
"version: 3.0.2\n"
"\n"

msgid ""
"name: guile\n"
"version: 2.2.7\n"
"@dots{}\n"
msgstr ""
"name: guile\n"
"version: 2.2.7\n"
"@dots{}\n"

msgid ""
"$ guix show guile@@3.0.5 | recsel -p name,version\n"
"name: guile\n"
"version: 3.0.5\n"
msgstr ""
"$ guix show guile@@3.0.5 | recsel -p name,version\n"
"name: guile\n"
"version: 3.0.5\n"

msgid "Guix supports transparent source/binary deployment, which means that it can either build things locally, or download pre-built items from a server, or both.  We call these pre-built items @dfn{substitutes}---they are substitutes for local build results.  In many cases, downloading a substitute is much faster than building things locally."
msgstr "Guix 支持透明的二进制/源码混合部署，既能本地构建，亦可从服务器下载预构建项目，或二者并行。这些预构建项目称为@dfn{替代品}——即本地构建结果的等效替代。多数场景下下载替代品远快于本地构建。"

msgid "Substitutes can be anything resulting from a derivation build (@pxref{Derivations}).  Of course, in the common case, they are pre-built package binaries, but source tarballs, for instance, which also result from derivation builds, can be available as substitutes."
msgstr "替代品可来自任意派生项构建结果（@pxref{Derivations}）。常见形式为预编译软件包二进制文件，但派生构建产生的源码压缩包等同样可作为替代品。"

msgid "build farm"
msgstr "构建集群"

msgid "@code{@value{SUBSTITUTE-SERVER-1}} and @code{@value{SUBSTITUTE-SERVER-2}} are both front-ends to official build farms that build packages from Guix continuously for some architectures, and make them available as substitutes.  These are the default source of substitutes; which can be overridden by passing the @option{--substitute-urls} option either to @command{guix-daemon} (@pxref{daemon-substitute-urls,, @code{guix-daemon --substitute-urls}})  or to client tools such as @command{guix package} (@pxref{client-substitute-urls,, client @option{--substitute-urls} option})."
msgstr "@code{@value{SUBSTITUTE-SERVER-1}} 与 @code{@value{SUBSTITUTE-SERVER-2}} 是官方构建集群的前端，持续为特定架构构建 Guix 软件包并提供替代品。此为默认替代渠道，可通过向 @command{guix-daemon} 传递 @option{--substitute-urls} 选项（@pxref{daemon-substitute-urls,, @code{guix-daemon --substitute-urls}}）或客户端工具如 @command{guix package}（@pxref{client-substitute-urls,, 客户端 @option{--substitute-urls} 选项}）覆盖默认设置。"

msgid "Substitute URLs can be either HTTP or HTTPS.  HTTPS is recommended because communications are encrypted; conversely, using HTTP makes all communications visible to an eavesdropper, who could use the information gathered to determine, for instance, whether your system has unpatched security vulnerabilities."
msgstr "替代品 URL 支持 HTTP 或 HTTPS 协议。推荐使用 HTTPS（通信加密），HTTP 则会使通信内容暴露于窃听者，可能被用于推断系统存在未修补漏洞等敏感信息。"

msgid "Substitutes from the official build farms are enabled by default when using Guix System (@pxref{GNU Distribution}).  However, they are disabled by default when using Guix on a foreign distribution, unless you have explicitly enabled them via one of the recommended installation steps (@pxref{Installation}).  The following paragraphs describe how to enable or disable substitutes for the official build farm; the same procedure can also be used to enable substitutes for any other substitute server."
msgstr "官方构建集群的替代品在使用 Guix 系统时默认启用（@pxref{GNU Distribution}）。但在外部发行版上使用 Guix 时默认禁用，除非已通过推荐安装步骤显式启用（@pxref{Installation}）。以下段落描述如何启用或禁用官方构建集群的替代品；相同流程亦可用于其他替代服务器的配置。"

msgid "security"
msgstr "安全"

msgid ""
"# guix archive --authorize < @var{prefix}/share/guix/@value{SUBSTITUTE-SERVER-1}.pub\n"
"# guix archive --authorize < @var{prefix}/share/guix/@value{SUBSTITUTE-SERVER-2}.pub\n"
msgstr ""
"# guix archive --authorize < @var{prefix}/share/guix/@value{SUBSTITUTE-SERVER-1}.pub\n"
"# guix archive --authorize < @var{prefix}/share/guix/@value{SUBSTITUTE-SERVER-2}.pub\n"

msgid ""
"$ guix build emacs --dry-run\n"
"The following derivations would be built:\n"
"   /gnu/store/yr7bnx8xwcayd6j95r2clmkdl1qh688w-emacs-24.3.drv\n"
"   /gnu/store/x8qsh1hlhgjx6cwsjyvybnfv2i37z23w-dbus-1.6.4.tar.gz.drv\n"
"   /gnu/store/1ixwp12fl950d15h2cj11c73733jay0z-alsa-lib-1.0.27.1.tar.bz2.drv\n"
"   /gnu/store/nlma1pw0p603fpfiqy7kn4zm105r5dmw-util-linux-2.21.drv\n"
"@dots{}\n"
msgstr ""
"$ guix build emacs --dry-run\n"
"将构建以下派生：\n"
"   /gnu/store/yr7bnx8xwcayd6j95r2clmkdl1qh688w-emacs-24.3.drv\n"
"   /gnu/store/x8qsh1hlhgjx6cwsjyvybnfv2i37z23w-dbus-1.6.4.tar.gz.drv\n"
"   /gnu/store/1ixwp12fl950d15h2cj11c73733jay0z-alsa-lib-1.0.27.1.tar.bz2.drv\n"
"   /gnu/store/nlma1pw0p603fpfiqy7kn4zm105r5dmw-util-linux-2.21.drv\n"
"@dots{}\n"

msgid ""
"$ guix build emacs --dry-run\n"
"112.3 MB would be downloaded:\n"
"   /gnu/store/pk3n22lbq6ydamyymqkkz7i69wiwjiwi-emacs-24.3\n"
"   /gnu/store/2ygn4ncnhrpr61rssa6z0d9x22si0va3-libjpeg-8d\n"
"   /gnu/store/71yz6lgx4dazma9dwn2mcjxaah9w77jq-cairo-1.12.16\n"
"   /gnu/store/7zdhgp0n1518lvfn8mb96sxqfmvqrl7v-libxrender-0.9.7\n"
"@dots{}\n"
msgstr ""
"$ guix build emacs --dry-run\n"
"将下载 112.3 MB：\n"
"   /gnu/store/pk3n22lbq6ydamyymqkkz7i69wiwjiwi-emacs-24.3\n"
"   /gnu/store/2ygn4ncnhrpr61rssa6z0d9x22si0va3-libjpeg-8d\n"
"   /gnu/store/71yz6lgx4dazma9dwn2mcjxaah9w77jq-cairo-1.12.16\n"
"   /gnu/store/7zdhgp0n1518lvfn8mb96sxqfmvqrl7v-libxrender-0.9.7\n"
"@dots{}\n"

msgid ""
"$ sudo guix system reconfigure /etc/config.scm\n"
"$ sudo herd restart guix-daemon\n"
msgstr ""
"$ sudo guix system reconfigure /etc/config.scm\n"
"$ sudo herd restart guix-daemon\n"

msgid "@dots{} --substitute-urls='https://guix.example.org @value{SUBSTITUTE-URLS}'\n"
msgstr "@dots{} --substitute-urls='https://guix.example.org @value{SUBSTITUTE-URLS}'\n"

msgid ""
"systemctl daemon-reload\n"
"systemctl restart guix-daemon.service\n"
msgstr ""
"systemctl daemon-reload\n"
"systemctl restart guix-daemon.service\n"

msgid "guix archive --authorize < key.pub\n"
msgstr "guix archive --authorize < key.pub\n"

msgid "guix weather coreutils\n"
msgstr "guix weather coreutils\n"

msgid "--substitute-urls=\"https://a.example.org https://b.example.org\"\n"
msgstr "--substitute-urls=\"https://a.example.org https://b.example.org\"\n"

msgid "guix install glib\n"
msgstr "guix install glib\n"

msgid "guix install glib:doc\n"
msgstr "guix install glib:doc\n"

msgid "Invoking @command{guix locate}"
msgstr "调用@command{guix locate}"

msgid "guix search video editor\n"
msgstr "guix search video editor\n"

msgid ""
"$ guix locate ls\n"
"coreutils@@9.1       /gnu/store/@dots{}-coreutils-9.1/bin/ls\n"
msgstr ""
"$ guix locate ls\n"
"coreutils@@9.1       /gnu/store/@dots{}-coreutils-9.1/bin/ls\n"

msgid ""
"$ guix locate unistr.h\n"
"icu4c@@71.1          /gnu/store/@dots{}/include/unicode/unistr.h\n"
"libunistring@@1.0    /gnu/store/@dots{}/include/unistr.h\n"
msgstr ""
"$ guix locate unistr.h\n"
"icu4c@@71.1          /gnu/store/@dots{}/include/unicode/unistr.h\n"
"libunistring@@1.0    /gnu/store/@dots{}/include/unistr.h\n"

msgid ""
"$ guix locate -g '*.service'\n"
"man-db@@2.11.1        @dots{}/lib/systemd/system/man-db.service\n"
"wpa-supplicant@@2.10  @dots{}/system-services/fi.w1.wpa_supplicant1.service\n"
msgstr ""
"$ guix locate -g '*.service'\n"
"man-db@@2.11.1        @dots{}/lib/systemd/system/man-db.service\n"
"wpa-supplicant@@2.10  @dots{}/system-services/fi.w1.wpa_supplicant1.service\n"

msgid "guix locate [@var{options}@dots{}] @var{file}@dots{}\n"
msgstr "guix locate [@var{options}@dots{}] @var{file}@dots{}\n"

msgid "Invoking @command{guix gc}"
msgstr "调用 @command{guix gc}"

msgid "guix gc"
msgstr "guix gc"

msgid "guix gc -F 5G\n"
msgstr "guix gc -F 5G\n"

msgid "guix gc -d 2m -F 10G\n"
msgstr "guix gc -d 2m -F 10G\n"

msgid "closure"
msgstr "closure"

msgid "derivation"
msgstr "derivation"

msgid "guix gc --derivers $(guix package -I ^emacs$ | cut -f4)\n"
msgstr "guix gc --derivers $(guix package -I ^emacs$ | cut -f4)\n"

msgid "Invoking @command{guix pull}"
msgstr "调用 @command{guix pull}"

msgid "Invoking @command{guix time-machine}"
msgstr "调用 @command{guix time-machine}"

msgid ""
"guix time-machine --commit=v1.2.0 -- \\\n"
"  environment -C --ad-hoc guile -- guile\n"
msgstr ""
"guix time-machine --commit=v1.2.0 -- \\\n"
"  environment -C --ad-hoc guile -- guile\n"

msgid "guix time-machine -q -- build hello\n"
msgstr "guix time-machine -q -- build hello\n"

msgid "guix time-machine @var{options}@dots{} -- @var{command} @var {arg}@dots{}\n"
msgstr "guix time-machine @var{options}@dots{} -- @var{command} @var {arg}@dots{}\n"

msgid "guix time-machine -C <(echo %default-channels) @dots{}\n"
msgstr "guix time-machine -C <(echo %default-channels) @dots{}\n"

msgid "Inferior packages can be used transparently like any other package or file-like object in G-expressions (@pxref{G-Expressions}).  They are also transparently handled by the @code{packages->manifest} procedure, which is commonly used in manifests (@pxref{Invoking guix package, the @option{--manifest} option of @command{guix package}}).  Thus you can insert an inferior package pretty much anywhere you would insert a regular package: in manifests, in the @code{packages} field of your @code{operating-system} declaration, and so on."
msgstr "下层包可以像 G-表达式中的任何其他包或文件对象一样透明地使用（@pxref{G-Expressions}）。它们也被 @code{packages->manifest} 程序透明地处理，该程序通常在清单中使用（@pxref{Invoking guix package, the @option{--manifest} option of @command{guix package}}）。因此，您几乎可以在任何您插入常规包的地方插入下层包：在清单中，在您的 @code{operating-system} 声明的 @code{packages} 字段中，等等。"

msgid "Invoking @command{guix describe}"
msgstr "调用 @command{guix describe}"

msgid "guix describe"
msgstr "guix describe"

msgid ""
"$ guix describe\n"
"Generation 10\tSep 03 2018 17:32:44\t(current)\n"
"  guix e0fa68c\n"
"    repository URL: https://git.guix.gnu.org/guix.git\n"
"    branch: master\n"
"    commit: e0fa68c7718fffd33d81af415279d6ddb518f727\n"
msgstr ""
"$ guix describe\n"
"第 10 代\t9月 03 2018 17:32:44\t(当前)\n"
"  guix e0fa68c\n"
"    仓库 URL：https://git.guix.gnu.org/guix.git\n"
"    分支：master\n"
"    提交：e0fa68c7718fffd33d81af415279d6ddb518f727\n"

msgid ""
"$ guix describe -f channels\n"
"(list (channel\n"
"        (name 'guix)\n"
"        (url \"https://git.guix.gnu.org/guix.git\")\n"
"        (commit\n"
"          \"e0fa68c7718fffd33d81af415279d6ddb518f727\")\n"
"        (introduction\n"
"          (make-channel-introduction\n"
"            \"9edb3f66fd807b096b48283debdcddccfea34bad\"\n"
"            (openpgp-fingerprint\n"
"              \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\")))))\n"
msgstr ""
"$ guix describe -f channels\n"
"(list (channel\n"
"        (name 'guix)\n"
"        (url \"https://git.guix.gnu.org/guix.git\")\n"
"        (commit\n"
"          \"e0fa68c7718fffd33d81af415279d6ddb518f727\")\n"
"        (introduction\n"
"          (make-channel-introduction\n"
"            \"9edb3f66fd807b096b48283debdcddccfea34bad\"\n"
"            (openpgp-fingerprint\n"
"              \"BBB0 2DDF 2CEA F6A8 0D1D  E643 A2A0 6DF2 A33A 54FA\")))))\n"

msgid "Invoking @command{guix archive}"
msgstr "调用 @command{guix archive}"

msgid "archive"
msgstr "归档"

msgid "guix archive --export @var{options} @var{specifications}...\n"
msgstr "guix archive --export @var{options} @var{specifications}...\n"

msgid "guix archive --export git:gui /gnu/store/...-emacs-24.3 > great.nar\n"
msgstr "guix archive --export git:gui /gnu/store/...-emacs-24.3 > great.nar\n"

msgid "guix archive --export -r emacs | ssh the-machine guix archive --import\n"
msgstr "guix archive --export -r emacs | ssh the-machine guix archive --import\n"

msgid ""
"guix archive --export -r $(readlink -f ~/.guix-profile) | \\\n"
"  ssh the-machine guix archive --import\n"
msgstr ""
"guix archive --export -r $(readlink -f ~/.guix-profile) | \\\n"
"  ssh the-machine guix archive --import\n"

msgid ""
"$ wget -O - \\\n"
"  https://@value{SUBSTITUTE-SERVER-1}/nar/gzip/@dots{}-emacs-24.5 \\\n"
"  | gunzip | guix archive -x /tmp/emacs\n"
msgstr ""
"$ wget -O - \\\n"
"  https://@value{SUBSTITUTE-SERVER-1}/nar/gzip/@dots{}-emacs-24.5 \\\n"
"  | gunzip | guix archive -x /tmp/emacs\n"

msgid ""
"$ wget -O - \\\n"
"  https://@value{SUBSTITUTE-SERVER-1}/nar/lzip/@dots{}-emacs-26.3 \\\n"
"  | lzip -d | guix archive -t\n"
msgstr ""
"$ wget -O - \\\n"
"  https://@value{SUBSTITUTE-SERVER-1}/nar/lzip/@dots{}-emacs-26.3 \\\n"
"  | lzip -d | guix archive -t\n"

msgid "Guix and its package collection are updated by running @command{guix pull}.  By default @command{guix pull} downloads and deploys Guix itself from the official GNU@tie{}Guix repository.  This can be customized by providing a file specifying the set of @dfn{channels} to pull from (@pxref{Invoking guix pull}).  A channel specifies the URL and branch of a Git repository to be deployed, and @command{guix pull} can be instructed to pull from one or more channels.  In other words, channels can be used to @emph{customize} and to @emph{extend} Guix, as we will see below.  Guix is able to take into account security concerns and deal with authenticated updates."
msgstr "通过运行 @command{guix pull} 可更新 Guix 及其软件包集合。默认情况下，@command{guix pull} 从官方 GNU@tie{}Guix 代码库下载并部署 Guix 本体。用户可通过配置文件指定拉取的@dfn{频道}集合实现定制（@pxref{Invoking guix pull}）。每个频道定义待部署 Git 代码库的 URL 与分支，@command{guix pull} 支持从单频道或多频道拉取。换言之，频道可用于@emph{定制}和@emph{扩展} Guix（详见下文）。Guix 具备安全机制保障认证更新的可靠性。"

msgid "extending the package collection (channels)"
msgstr "扩展软件包集合（频道）"

msgid "variant packages (channels)"
msgstr "变体软件包（频道）"

msgid "You can specify @emph{additional channels} to pull from.  To use a channel, write @code{~/.config/guix/channels.scm} to instruct @command{guix pull} to pull from it @emph{in addition} to the default Guix channel(s):"
msgstr "可通过指定@emph{额外频道}扩展拉取源。要启用某频道，需编写 @code{~/.config/guix/channels.scm} 文件，指示 @command{guix pull} 在默认频道基础上追加拉取该频道："

msgid "%default-channels"
msgstr "%default-channels"

msgid ""
";; Add variant packages to those Guix provides.\n"
"(cons (channel\n"
"        (name 'variant-packages)\n"
"        (url \"https://example.org/variant-packages.git\"))\n"
"      %default-channels)\n"
msgstr ""
";; 添加变体软件包至 Guix 提供的基础包集。\n"
"(cons (channel\n"
"        (name 'variant-packages)\n"
"        (url \"https://example.org/variant-packages.git\"))\n"
"      %default-channels)\n"

msgid ""
"$ guix describe\n"
"Generation 19\tAug 27 2018 16:20:48\n"
"  guix d894ab8\n"
"    repository URL: https://git.guix.gnu.org/guix.git\n"
"    branch: master\n"
"    commit: d894ab8e9bfabcefa6c49d9ba2e834dd5a73a300\n"
"  variant-packages dd3df5e\n"
"    repository URL: https://example.org/variant-packages.git\n"
"    branch: master\n"
"    commit: dd3df5e2c8818760a8fc0bd699e55d3b69fef2bb\n"
msgstr ""
"$ guix describe\n"
"第 19 代\t8月 27 2018 16:20:48\n"
"  guix d894ab8\n"
"    仓库 URL：https://git.guix.gnu.org/guix.git\n"
"    分支：master\n"
"    提交：d894ab8e9bfabcefa6c49d9ba2e834dd5a73a300\n"
"  variant-packages dd3df5e\n"
"    仓库 URL：https://example.org/variant-packages.git\n"
"    分支：master\n"
"    提交：dd3df5e2c8818760a8fc0bd699e55d3b69fef2bb\n"

msgid ""
"[safe]\n"
"        directory = /src/guix.git\n"
msgstr ""
"[safe]\n"
"        directory = /src/guix.git\n"

msgid ""
";; Deploy specific commits of my channels of interest.\n"
"(list (channel\n"
"       (name 'guix)\n"
"       (url \"https://git.guix.gnu.org/guix.git\")\n"
"       (commit \"6298c3ffd9654d3231a6f25390b056483e8f407c\"))\n"
"      (channel\n"
"       (name 'variant-packages)\n"
"       (url \"https://example.org/variant-packages.git\")\n"
"       (commit \"dd3df5e2c8818760a8fc0bd699e55d3b69fef2bb\")))\n"
msgstr ""
";; 部署我感兴趣的频道的特定提交。\n"
"(list (channel\n"
"       (name 'guix)\n"
"       (url \"https://git.guix.gnu.org/guix.git\")\n"
"       (commit \"6298c3ffd9654d3231a6f25390b056483e8f407c\"))\n"
"      (channel\n"
"       (name 'variant-packages)\n"
"       (url \"https://example.org/variant-packages.git\")\n"
"       (commit \"dd3df5e2c8818760a8fc0bd699e55d3b69fef2bb\")))\n"

msgid "guix describe -f channels > channels.scm\n"
msgstr "guix describe -f channels > channels.scm\n"

msgid "guix time-machine -C channels.scm -- shell python -- python3\n"
msgstr "guix time-machine -C channels.scm -- shell python -- python3\n"

msgid ""
"(define my-channels\n"
"  ;; Channels that should be available to\n"
"  ;; /run/current-system/profile/bin/guix.\n"
"  (append\n"
"   (list (channel\n"
"          (name 'guix-science)\n"
"          (url \"https://codeberg.org/guix-science/guix-science\")\n"
"          (branch \"master\")))\n"
"   %default-channels))\n"
"\n"
msgstr ""
"(define my-channels\n"
"  ;; 应该对\n"
"  ;; /run/current-system/profile/bin/guix 可用的频道。\n"
"  (append\n"
"   (list (channel\n"
"          (name 'guix-science)\n"
"          (url \"https://codeberg.org/guix-science/guix-science\")\n"
"          (branch \"master\")))\n"
"   %default-channels))\n"
"\n"

msgid ""
"mkdir my-channel\n"
"cd my-channel\n"
"git init\n"
msgstr ""
"mkdir my-channel\n"
"cd my-channel\n"
"git init\n"

msgid ""
"mkdir -p alice/packages\n"
"$EDITOR alice/packages/greetings.scm\n"
"git add alice/packages/greetings.scm\n"
msgstr ""
"mkdir -p alice/packages\n"
"$EDITOR alice/packages/greetings.scm\n"
"git add alice/packages/greetings.scm\n"

msgid "guix build -L. hi-from-alice\n"
msgstr "guix build -L. hi-from-alice\n"

msgid "git commit\n"
msgstr "git commit\n"

msgid ""
"$EDITOR ~/.config/guix/channels.scm\n"
"guix pull\n"
msgstr ""
"$EDITOR ~/.config/guix/channels.scm\n"
"guix pull\n"

msgid "guix git authenticate @var{commit} @var{signer}\n"
msgstr "guix git authenticate @var{commit} @var{signer}\n"

msgid "xgettext -o news.po -l scheme -ken etc/news.txt\n"
msgstr "xgettext -o news.po -l scheme -ken etc/news.txt\n"

msgid "Invoking @command{guix shell}"
msgstr "调用 @command{guix shell}"

msgid "guix shell"
msgstr "guix shell"

msgid "guix shell [@var{options}] [@var{package}@dots{}]\n"
msgstr "guix shell [@var{options}] [@var{package}@dots{}]\n"

msgid "guix shell python python-numpy -- python3\n"
msgstr "guix shell python python-numpy -- python3\n"

msgid ""
"#!/usr/bin/env -S guix shell python python-numpy -- python3\n"
"import numpy\n"
"print(\"This is numpy\", numpy.version.version)\n"
msgstr ""
"#!/usr/bin/env -S guix shell python python-numpy -- python3\n"
"import numpy\n"
"print(\"This is numpy\", numpy.version.version)\n"

msgid "guix shell --development inkscape\n"
msgstr "guix shell --development inkscape\n"

msgid "guix shell\n"
msgstr "guix shell\n"

msgid "guix shell --container emacs gcc-toolchain\n"
msgstr "guix shell --container emacs gcc-toolchain\n"

msgid ""
"guix shell --container --network --no-cwd ungoogled-chromium \\\n"
"  --preserve='^XAUTHORITY$' --expose=\"$@{XAUTHORITY@}\" \\\n"
"  --preserve='^DISPLAY$' -- chromium\n"
msgstr ""
"guix shell --container --network --no-cwd ungoogled-chromium \\\n"
"  --preserve='^XAUTHORITY$' --expose=\"$@{XAUTHORITY@}\" \\\n"
"  --preserve='^DISPLAY$' -- chromium\n"

msgid ""
"if [ -n \"$GUIX_ENVIRONMENT\" ]\n"
"then\n"
"    export PS1=\"\\u@@\\h \\w [dev]\\$ \"\n"
"fi\n"
msgstr ""
"if [ -n \"$GUIX_ENVIRONMENT\" ]\n"
"then\n"
"    export PS1=\"\\u@@\\h \\w [dev]\\$ \"\n"
"fi\n"

msgid "$ ls \"$GUIX_ENVIRONMENT/bin\"\n"
msgstr "$ ls \"$GUIX_ENVIRONMENT/bin\"\n"

msgid "guix shell -D guile autoconf automake libtool\n"
msgstr "guix shell -D guile autoconf automake libtool\n"

msgid "guix shell -D -e '(@@ (gnu packages maths) petsc-openmpi)'\n"
msgstr "guix shell -D -e '(@@ (gnu packages maths) petsc-openmpi)'\n"

msgid "guix shell -e '(@@ (gnu) %base-packages)'\n"
msgstr "guix shell -e '(@@ (gnu) %base-packages)'\n"

msgid "guix shell -e '(list (@@ (gnu packages bash) bash) \"include\")'\n"
msgstr "guix shell -e '(list (@@ (gnu packages bash) bash) \"include\")'\n"

msgid "guix shell -D -f gdb-devel.scm\n"
msgstr "guix shell -D -f gdb-devel.scm\n"

msgid "guix shell -D guile git emacs emacs-geiser emacs-geiser-guile\n"
msgstr "guix shell -D guile git emacs emacs-geiser emacs-geiser-guile\n"

msgid ""
"guix shell --export-manifest \\\n"
"  -D guile git emacs emacs-geiser emacs-geiser-guile\n"
msgstr ""
"guix shell --export-manifest \\\n"
"  -D guile git emacs emacs-geiser emacs-geiser-guile\n"

msgid "guix shell -m manifest.scm\n"
msgstr "guix shell -m manifest.scm\n"

msgid ""
"guix shell --pure --preserve=^SLURM openmpi @dots{} \\\n"
"  -- mpirun @dots{}\n"
msgstr ""
"guix shell --pure --preserve=^SLURM openmpi @dots{} \\\n"
"  -- mpirun @dots{}\n"

msgid "container"
msgstr "container"

msgid ""
"# will expose paths as /home/foo/wd, /home/foo/test, and /home/foo/target\n"
"cd $HOME/wd\n"
"guix shell --container --user=foo \\\n"
"     --expose=$HOME/test \\\n"
"     --expose=/tmp/target=$HOME/target\n"
msgstr ""
"# 容器内将映射以下路径：/home/foo/wd、/home/foo/test、/home/foo/target \n"
"cd $HOME/wd\n"
"guix shell --container --user=foo \\\n"
"     --expose=$HOME/test \\\n"
"     --expose=/tmp/target=$HOME/target\n"

msgid "guix shell --container --expose=$HOME=/exchange guile -- guile\n"
msgstr "guix shell --container --expose=$HOME=/exchange guile -- guile\n"

msgid ""
"$ guix shell -CW coreutils\n"
"[env]$ guix shell -C guile -- guile -c '(display \"hello!\\n\")'\n"
"hello!\n"
"[env]$ exit\n"
msgstr ""
"$ guix shell -CW coreutils\n"
"[env]$ guix shell -C guile -- guile -c '(display \"hello!\\n\")'\n"
"hello!\n"
"[env]$ exit\n"

msgid "guix shell -CW -- guix build -f guix.scm\n"
msgstr "guix shell -CW -- guix build -f guix.scm\n"

msgid "Invoking @command{guix environment}"
msgstr "调用 @command{guix environment}"

msgid "guix environment @var{options} @var{package}@dots{}\n"
msgstr "guix environment @var{options} @var{package}@dots{}\n"

msgid "guix environment guile\n"
msgstr "guix environment guile\n"

msgid "guix environment guile emacs\n"
msgstr "guix environment guile emacs\n"

msgid "guix environment guile -- make -j4\n"
msgstr "guix environment guile -- make -j4\n"

msgid "guix environment --ad-hoc python-numpy python -- python3\n"
msgstr "guix environment --ad-hoc python-numpy python -- python3\n"

msgid "guix environment --pure guix --ad-hoc git strace\n"
msgstr "guix environment --pure guix --ad-hoc git strace\n"

msgid "guix environment --ad-hoc --container guile -- guile\n"
msgstr "guix environment --ad-hoc --container guile -- guile\n"

msgid ""
"guix environment --preserve='^DISPLAY$' --container --network \\\n"
"  --expose=/etc/machine-id \\\n"
"  --expose=/etc/ssl/certs/ \\\n"
"  --share=$HOME/.local/share/eolie/=$HOME/.local/share/eolie/ \\\n"
"  --ad-hoc eolie nss-certs dbus --  eolie\n"
msgstr ""
"guix environment --preserve='^DISPLAY$' --container --network \\\n"
"  --expose=/etc/machine-id \\\n"
"  --expose=/etc/ssl/certs/ \\\n"
"  --share=$HOME/.local/share/eolie/=$HOME/.local/share/eolie/ \\\n"
"  --ad-hoc eolie nss-certs dbus --  eolie\n"

msgid "guix environment -e '(@@ (gnu packages maths) petsc-openmpi)'\n"
msgstr "guix environment -e '(@@ (gnu packages maths) petsc-openmpi)'\n"

msgid "guix environment --ad-hoc -e '(@@ (gnu) %base-packages)'\n"
msgstr "guix environment --ad-hoc -e '(@@ (gnu) %base-packages)'\n"

msgid "guix environment --ad-hoc -e '(list (@@ (gnu packages bash) bash) \"include\")'\n"
msgstr "guix environment --ad-hoc -e '(list (@@ (gnu packages bash) bash) \"include\")'\n"

msgid "guix environment --ad-hoc guile guile-sdl -- guile\n"
msgstr "guix environment --ad-hoc guile guile-sdl -- guile\n"

msgid ""
"guix environment --pure --preserve=^SLURM --ad-hoc openmpi @dots{} \\\n"
"  -- mpirun @dots{}\n"
msgstr ""
"guix environment --pure --preserve=^SLURM --ad-hoc openmpi @dots{} \\\n"
"  -- mpirun @dots{}\n"

msgid ""
"# will expose paths as /home/foo/wd, /home/foo/test, and /home/foo/target\n"
"cd $HOME/wd\n"
"guix environment --container --user=foo \\\n"
"     --expose=$HOME/test \\\n"
"     --expose=/tmp/target=$HOME/target\n"
msgstr ""
"# 容器内将映射以下路径：/home/foo/wd、/home/foo/test、/home/foo/target \n"
"cd $HOME/wd\n"
"guix environment --container --user=foo \\\n"
"     --expose=$HOME/test \\\n"
"     --expose=/tmp/target=$HOME/target\n"

msgid "guix environment --container --expose=$HOME=/exchange --ad-hoc guile -- guile\n"
msgstr "guix environment --container --expose=$HOME=/exchange --ad-hoc guile -- guile\n"

msgid "Invoking @command{guix pack}"
msgstr "调用 @command{guix pack}"

msgid "guix pack"
msgstr "guix pack"

msgid ""
"$ guix pack guile emacs emacs-geiser\n"
"@dots{}\n"
"/gnu/store/@dots{}-pack.tar.gz\n"
msgstr ""
"$ guix pack guile emacs emacs-geiser\n"
"@dots{}\n"
"/gnu/store/@dots{}-pack.tar.gz\n"

msgid "guix pack -S /opt/gnu/bin=bin guile emacs emacs-geiser\n"
msgstr "guix pack -S /opt/gnu/bin=bin guile emacs emacs-geiser\n"

msgid "guix pack -f docker -S /bin=bin guile guile-readline\n"
msgstr "guix pack -f docker -S /bin=bin guile guile-readline\n"

msgid ""
"docker load < @var{file}\n"
"docker run -ti guile-guile-readline /bin/guile\n"
msgstr ""
"docker load < @var{file}\n"
"docker run -ti guile-guile-readline /bin/guile\n"

msgid "guix pack -f squashfs bash guile emacs emacs-geiser\n"
msgstr "guix pack -f squashfs bash guile emacs emacs-geiser\n"

msgid ""
"file=$(guix pack -f appimage --entry-point=bin/guile guile)\n"
"$file --help\n"
msgstr ""
"file=$(guix pack -f appimage --entry-point=bin/guile guile)\n"
"$file --help\n"

msgid "guix pack -f squashfs bash @dots{}\n"
msgstr "guix pack -f squashfs bash @dots{}\n"

msgid "guix pack -f deb -C xz -S /usr/bin/hello=bin/hello hello\n"
msgstr "guix pack -f deb -C xz -S /usr/bin/hello=bin/hello hello\n"

msgid "guix pack -f rpm -R -C xz -S /usr/bin/hello=bin/hello hello\n"
msgstr "guix pack -f rpm -R -C xz -S /usr/bin/hello=bin/hello hello\n"

msgid "sudo rpm --install --prefix=/opt /gnu/store/...-hello.rpm\n"
msgstr "sudo rpm --install --prefix=/opt /gnu/store/...-hello.rpm\n"

msgid "guix pack -f appimage --entry-point=bin/vlc vlc\n"
msgstr "guix pack -f appimage --entry-point=bin/vlc vlc\n"

msgid "guix pack -f appimage --entry-point=bin/hello --relocatable hello\n"
msgstr "guix pack -f appimage --entry-point=bin/hello --relocatable hello\n"

msgid "guix pack -RR -S /mybin=bin bash\n"
msgstr "guix pack -RR -S /mybin=bin bash\n"

msgid ""
"tar xf pack.tar.gz\n"
"./mybin/sh\n"
msgstr ""
"tar xf pack.tar.gz\n"
"./mybin/sh\n"

msgid "performance"
msgstr "performance"

msgid "userns"
msgstr "userns"

msgid "proot"
msgstr "proot"

msgid "fakechroot"
msgstr "fakechroot"

msgid "guix pack -f docker --entry-point=bin/guile guile\n"
msgstr "guix pack -f docker --entry-point=bin/guile guile\n"

msgid ""
"docker load -i pack.tar.gz\n"
"docker run @var{image-id}\n"
msgstr ""
"docker load -i pack.tar.gz\n"
"docker run @var{image-id}\n"

msgid "guix pack -f docker --entry-point=bin/guile --entry-point-argument=\"--help\" guile\n"
msgstr "guix pack -f docker --entry-point=bin/guile --entry-point-argument=\"--help\" guile\n"

msgid "guix pack -f docker --max-layers=100 guile\n"
msgstr "guix pack -f docker --max-layers=100 guile\n"

msgid "If you need a complete toolchain for compiling and linking C or C++ source code, use the @code{gcc-toolchain} package.  This package provides a complete GCC toolchain for C/C++ development, including GCC itself, the GNU C Library (headers and binaries, plus debugging symbols in the @code{debug} output), Binutils, and a linker wrapper."
msgstr "若需完整的 C/C++ 源码编译工具链，请使用 @code{gcc-toolchain} 软件包。该软件包提供完整的 C/C++ 开发 GCC 工具链，包含 GCC 本体、GNU C 语言运行库（含头文件与二进制文件，调试符号位于 @code{debug} 输出）、Binutils 工具集及链接器包装程序。"

msgid "The wrapper's purpose is to inspect the @code{-L} and @code{-l} switches passed to the linker, add corresponding @code{-rpath} arguments, and invoke the actual linker with this new set of arguments.  You can instruct the wrapper to refuse to link against libraries not in the store by setting the @env{GUIX_LD_WRAPPER_ALLOW_IMPURITIES} environment variable to @code{no}."
msgstr "链接器包装程序的功能是解析传递给链接器的 @code{-L} 和 @code{-l} 选项，添加对应的 @code{-rpath} 参数，并基于新参数集调用实际链接器。通过设置环境变量 @env{GUIX_LD_WRAPPER_ALLOW_IMPURITIES} 为 @code{no}，可强制包装程序拒绝链接存储区外的库文件。"

msgid "The package @code{gfortran-toolchain} provides a complete GCC toolchain for Fortran development.  For other languages, please use @samp{guix search gcc toolchain} (@pxref{guix-search,, Invoking guix package})."
msgstr "@code{gfortran-toolchain} 软件包提供完整的 Fortran 开发 GCC 工具链。其他语言工具链请使用 @samp{guix search gcc toolchain}（@pxref{guix-search,, Invoking guix package}）。"

msgid "Invoking @command{guix git authenticate}"
msgstr "调用 @command{guix git authenticate}"

msgid "guix git authenticate"
msgstr "guix git authenticate"

msgid "guix git authenticate @var{commit} @var{signer} [@var{options}@dots{}]\n"
msgstr "guix git authenticate @var{commit} @var{signer} [@var{options}@dots{}]\n"

msgid "guix git authenticate [@var{options}@dots{}]\n"
msgstr "guix git authenticate [@var{options}@dots{}]\n"

msgid "source"
msgstr "source"

msgid "build-system"
msgstr "build-system"

msgid "synopsis"
msgstr "synopsis"

msgid "description"
msgstr "description"

msgid "license"
msgstr "license"

msgid "home-page"
msgstr "home-page"

msgid "this-package"
msgstr "this-package"

msgid ""
"(git-reference\n"
"  (url \"https://git.savannah.gnu.org/git/hello.git\")\n"
"  (commit \"v2.10\"))\n"
msgstr ""
"(git-reference\n"
"  (url \"https://git.savannah.gnu.org/git/hello.git\")\n"
"  (commit \"v2.10\"))\n"

msgid "revision"
msgstr "revision"

msgid "module"
msgstr "module"

msgid "(append @var{package}@dots{})"
msgstr "(append @var{软件包}@dots{})"

msgid ""
"guix build guix \\\n"
"  --with-branch=guile-gcrypt=master \\\n"
"  --with-debug-info=zlib\n"
msgstr ""
"guix build guix \\\n"
"  --with-branch=guile-gcrypt=master \\\n"
"  --with-debug-info=zlib\n"

msgid "manifest"
msgstr "清单"

msgid "guix package -m manifest.scm\n"
msgstr "guix package -m manifest.scm\n"

msgid ""
"# Write to 'manifest.scm' a manifest corresponding to the\n"
"# default profile, ~/.guix-profile.\n"
"guix package --export-manifest > manifest.scm\n"
msgstr ""
"# 将默认软件集 ~/.guix-profile 对应的清单写入 'manifest.scm' \n"
"guix package --export-manifest > manifest.scm\n"

msgid ""
"# Write a manifest for the packages specified on the command line.\n"
"guix shell --export-manifest gcc-toolchain make git > manifest.scm\n"
msgstr ""
"# 为命令行指定的软件包生成清单。\n"
"guix shell --export-manifest gcc-toolchain make git > manifest.scm\n"

msgid ""
"(use-modules (gnu packages version-control))\n"
"\n"
msgstr ""
"(use-modules (gnu packages version-control))\n"
"\n"

msgid "build system"
msgstr "构建系统"

msgid "build"
msgstr "build"

msgid "cmake-build-system"
msgstr "cmake-build-system"

msgid "bootstrap"
msgstr "bootstrap"

msgid ""
"#!location/of/bin/bash\n"
"export PATH=\"/gnu/.../bar/bin\"\n"
"export CERT_PATH=\"$CERT_PATH$@{CERT_PATH:+:@}/gnu/.../baz/certs:/qux/certs\"\n"
"exec -a $0 location/of/.foo-real \"$@@\"\n"
msgstr ""
"#!location/of/bin/bash\n"
"export PATH=\"/gnu/.../bar/bin\"\n"
"export CERT_PATH=\"$CERT_PATH$@{CERT_PATH:+:@}/gnu/.../baz/certs:/qux/certs\"\n"
"exec -a $0 location/of/.foo-real \"$@@\"\n"

msgid ""
"$ guix shell python python-numpy --pure --search-paths\n"
"export PATH=\"/gnu/store/@dots{}-profile/bin\"\n"
"export GUIX_PYTHONPATH=\"/gnu/store/@dots{}-profile/lib/python3.9/site-packages\"\n"
msgstr ""
"$ guix shell python python-numpy --pure --search-paths\n"
"export PATH=\"/gnu/store/@dots{}-profile/bin\"\n"
"export GUIX_PYTHONPATH=\"/gnu/store/@dots{}-profile/lib/python3.9/site-packages\"\n"

msgid ""
"$ guix shell python python-numpy -- python3\n"
"Python 3.9.6 (default, Jan  1 1970, 00:00:01)\n"
"[GCC 10.3.0] on linux\n"
"Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n"
">>> import numpy\n"
">>> numpy.version.version\n"
"'1.20.3'\n"
msgstr ""
"$ guix shell python python-numpy -- python3\n"
"Python 3.9.6 (default, Jan  1 1970, 00:00:01)\n"
"[GCC 10.3.0] on linux\n"
"Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n"
">>> import numpy\n"
">>> numpy.version.version\n"
"'1.20.3'\n"

msgid ""
"$ guix shell python-numpy --search-paths --pure\n"
"export PATH=\"/gnu/store/@dots{}-profile/bin\"\n"
msgstr ""
"$ guix shell python-numpy --search-paths --pure\n"
"export PATH=\"/gnu/store/@dots{}-profile/bin\"\n"

msgid "guix://master.guix.example.org:1234\n"
msgstr "guix://master.guix.example.org:1234\n"

msgid "ssh://charlie@@guix.example.org:22\n"
msgstr "ssh://charlie@@guix.example.org:22\n"

msgid ""
"scheme@@(guile-user)> ,run-in-store (package->derivation hello)\n"
"$1 = #<derivation /gnu/store/@dots{}-hello-2.9.drv => @dots{}>\n"
msgstr ""
"scheme@@(guile-user)> ,run-in-store (package->derivation hello)\n"
"$1 = #<derivation /gnu/store/@dots{}-hello-2.9.drv => @dots{}>\n"

msgid ""
"scheme@@(guile-user)> ,enter-store-monad\n"
"store-monad@@(guile-user) [1]> (package->derivation hello)\n"
"$2 = #<derivation /gnu/store/@dots{}-hello-2.9.drv => @dots{}>\n"
"store-monad@@(guile-user) [1]> (text-file \"foo\" \"Hello!\")\n"
"$3 = \"/gnu/store/@dots{}-foo\"\n"
"store-monad@@(guile-user) [1]> ,q\n"
"scheme@@(guile-user)>\n"
msgstr ""
"scheme@@(guile-user)> ,enter-store-monad\n"
"store-monad@@(guile-user) [1]> (package->derivation hello)\n"
"$2 = #<derivation /gnu/store/@dots{}-hello-2.9.drv => @dots{}>\n"
"store-monad@@(guile-user) [1]> (text-file \"foo\" \"Hello!\")\n"
"$3 = \"/gnu/store/@dots{}-foo\"\n"
"store-monad@@(guile-user) [1]> ,q\n"
"scheme@@(guile-user)>\n"

msgid "G-expression"
msgstr "G-表达式"

msgid ""
"(@var{file-name} @var{obj})\n"
"(@var{file-name} @var{obj} @var{output})\n"
"(@var{file-name} @var{gexp-input})\n"
"(@var{file-name} @var{store-item})\n"
msgstr ""
"(@var{file-name} @var{obj})\n"
"(@var{file-name} @var{obj} @var{output})\n"
"(@var{file-name} @var{gexp-input})\n"
"(@var{file-name} @var{store-item})\n"

msgid ""
"#!/gnu/store/@dots{}-guile-2.0.11/bin/guile -ds\n"
"!#\n"
"(execl \"/gnu/store/@dots{}-coreutils-8.22\"/bin/ls\" \"ls\")\n"
msgstr ""
"#!/gnu/store/@dots{}-guile-2.0.11/bin/guile -ds\n"
"!#\n"
"(execl \"/gnu/store/@dots{}-coreutils-8.22\"/bin/ls\" \"ls\")\n"

msgid "Invoking @command{guix repl}"
msgstr "调用 @command{guix repl}"

msgid "guix repl"
msgstr "guix repl"

msgid "guix repl @var{options} [@var{file} @var{args}]\n"
msgstr "guix repl @var{options} [@var{file} @var{args}]\n"

msgid "guix repl my-script.scm\n"
msgstr "guix repl my-script.scm\n"

msgid "guix repl -- my-script.scm --input=foo.txt\n"
msgstr "guix repl -- my-script.scm --input=foo.txt\n"

msgid ""
"@code{#!/usr/bin/env -S guix repl --}\n"
"@code{!#}\n"
msgstr ""
"@code{#!/usr/bin/env -S guix repl --}\n"
"@code{!#}\n"

msgid ""
"@code{#!/usr/bin/env -S guix repl --interactive}\n"
"@code{!#}\n"
msgstr ""
"@code{#!/usr/bin/env -S guix repl --interactive}\n"
"@code{!#}\n"

msgid ""
"$ guix repl\n"
"scheme@@(guile-user)> ,use (gnu packages base)\n"
"scheme@@(guile-user)> coreutils\n"
"$1 = #<package coreutils@@8.29 gnu/packages/base.scm:327 3e28300>\n"
msgstr ""
"$ guix repl\n"
"scheme@@(guile-user)> ,use (gnu packages base)\n"
"scheme@@(guile-user)> coreutils\n"
"$1 = #<package coreutils@@8.29 gnu/packages/base.scm:327 3e28300>\n"

msgid "guix install guile guile-readline guile-colorized\n"
msgstr "guix install guile guile-readline guile-colorized\n"

msgid ""
"$ guix repl\n"
"scheme@@(guix-user)> (+ 2 3)\n"
"$1 = 5\n"
"scheme@@(guix-user)> (string-append \"a\" \"b\")\n"
"$2 = \"ab\"\n"
msgstr ""
"$ guix repl\n"
"scheme@@(guix-user)> (+ 2 3)\n"
"$1 = 5\n"
"scheme@@(guix-user)> (string-append \"a\" \"b\")\n"
"$2 = \"ab\"\n"

msgid ""
"scheme@@(guix-user)> ,use (guix)\n"
"scheme@@(guix-user)> ,use (gnu packages base)\n"
msgstr ""
"scheme@@(guix-user)> ,use (guix)\n"
"scheme@@(guix-user)> ,use (gnu packages base)\n"

msgid ""
"scheme@@(guix-user)> ,build coreutils\n"
"$1 = \"/gnu/store/@dots{}-coreutils-8.32-debug\"\n"
"$2 = \"/gnu/store/@dots{}-coreutils-8.32\"\n"
"scheme@@(guix-user)> ,build grep\n"
"$3 = \"/gnu/store/@dots{}-grep-3.6\"\n"
"scheme@@(guix-user)> ,build (computed-file \"x\" #~(mkdir #$output))\n"
"building /gnu/store/@dots{}-x.drv...\n"
"$4 = \"/gnu/store/@dots{}-x\"\n"
"scheme@@(guix-user)> ,use(ice-9 ftw)\n"
"scheme@@(guix-user)> (scandir (string-append $3 \"/bin\"))\n"
"$5 = (\".\" \"..\" \"egrep\" \"fgrep\" \"grep\")\n"
msgstr ""
"scheme@@(guix-user)> ,build coreutils\n"
"$1 = \"/gnu/store/@dots{}-coreutils-8.32-debug\"\n"
"$2 = \"/gnu/store/@dots{}-coreutils-8.32\"\n"
"scheme@@(guix-user)> ,build grep\n"
"$3 = \"/gnu/store/@dots{}-grep-3.6\"\n"
"scheme@@(guix-user)> ,build (computed-file \"x\" #~(mkdir #$output))\n"
"building /gnu/store/@dots{}-x.drv...\n"
"$4 = \"/gnu/store/@dots{}-x\"\n"
"scheme@@(guix-user)> ,use(ice-9 ftw)\n"
"scheme@@(guix-user)> (scandir (string-append $3 \"/bin\"))\n"
"$5 = (\".\" \"..\" \"egrep\" \"fgrep\" \"grep\")\n"

msgid ""
"scheme@@(guix-user)> ,phases grep\n"
"$1 = (modify-phases %standard-phases\n"
"       (add-after 'install 'fix-egrep-and-fgrep\n"
"         (lambda* (#:key outputs #:allow-other-keys)\n"
"           (let* ((out (assoc-ref outputs \"out\"))\n"
"                  (bin (string-append out \"/bin\")))\n"
"             (substitute* (list (string-append bin \"/egrep\")\n"
"                                (string-append bin \"/fgrep\"))\n"
"               ((\"^exec grep\")\n"
"                (string-append \"exec \" bin \"/grep\")))))))\n"
"scheme@@(guix-user)> ,configure-flags findutils\n"
"$2 = (list \"--localstatedir=/var\")\n"
"scheme@@(guix-user)> ,make-flags binutils\n"
"$3 = '(\"MAKEINFO=true\")\n"
msgstr ""
"scheme@@(guix-user)> ,phases grep\n"
"$1 = (modify-phases %standard-phases\n"
"       (add-after 'install 'fix-egrep-and-fgrep\n"
"         (lambda* (#:key outputs #:allow-other-keys)\n"
"           (let* ((out (assoc-ref outputs \"out\"))\n"
"                  (bin (string-append out \"/bin\")))\n"
"             (substitute* (list (string-append bin \"/egrep\")\n"
"                                (string-append bin \"/fgrep\"))\n"
"               ((\"^exec grep\")\n"
"                (string-append \"exec \" bin \"/grep\")))))))\n"
"scheme@@(guix-user)> ,configure-flags findutils\n"
"$2 = (list \"--localstatedir=/var\")\n"
"scheme@@(guix-user)> ,make-flags binutils\n"
"$3 = '(\"MAKEINFO=true\")\n"

msgid ""
"scheme@@(guix-user)> ,lower grep\n"
"$6 = #<derivation /gnu/store/@dots{}-grep-3.6.drv => /gnu/store/@dots{}-grep-3.6 7f0e639115f0>\n"
"scheme@@(guix-user)> ,lower (plain-file \"x\" \"Hello!\")\n"
"$7 = \"/gnu/store/@dots{}-x\"\n"
msgstr ""
"scheme@@(guix-user)> ,lower grep\n"
"$6 = #<derivation /gnu/store/@dots{}-grep-3.6.drv => /gnu/store/@dots{}-grep-3.6 7f0e639115f0>\n"
"scheme@@(guix-user)> ,lower (plain-file \"x\" \"Hello!\")\n"
"$7 = \"/gnu/store/@dots{}-x\"\n"

msgid "guix build @var{options} @var{package-or-derivation}@dots{}\n"
msgstr "guix build @var{options} @var{package-or-derivation}@dots{}\n"

msgid "guix build emacs guile\n"
msgstr "guix build emacs guile\n"

msgid ""
"guix build --quiet --keep-going \\\n"
"  $(guix package -A | awk '@{ print $1 \"@@\" $2 @}')\n"
msgstr ""
"guix build --quiet --keep-going \\\n"
"  $(guix package -A | awk '@{ print $1 \"@@\" $2 @}')\n"

msgid "$ export GUIX_BUILD_OPTIONS=\"--no-substitutes -c 2 -L /foo/bar\"\n"
msgstr "$ export GUIX_BUILD_OPTIONS=\"--no-substitutes -c 2 -L /foo/bar\"\n"

msgid "package transformation"
msgstr "包转换"

msgid "package variants, transformation"
msgstr "软件包变体, 转换"

msgid "guix build ed --with-source=mirror://gnu/ed/ed-1.4.tar.gz\n"
msgstr "guix build ed --with-source=mirror://gnu/ed/ed-1.4.tar.gz\n"

msgid "guix build elogind --with-source=@dots{}/shepherd-0.9.0rc1.tar.gz\n"
msgstr "guix build elogind --with-source=@dots{}/shepherd-0.9.0rc1.tar.gz\n"

msgid ""
"$ git clone git://git.sv.gnu.org/guix.git\n"
"$ guix build guix --with-source=guix@@1.0=./guix\n"
msgstr ""
"$ git clone git://git.sv.gnu.org/guix.git\n"
"$ guix build guix --with-source=guix@@1.0=./guix\n"

msgid "guix build --with-input=guile=guile@@2.2 guix\n"
msgstr "guix build --with-input=guile=guile@@2.2 guix\n"

msgid "guix build --with-graft=gnutls=gnutls@@3.5.4 wget\n"
msgstr "guix build --with-graft=gnutls=gnutls@@3.5.4 wget\n"

msgid "guix install inkscape --with-debug-info=glib\n"
msgstr "guix install inkscape --with-debug-info=glib\n"

msgid ""
"guix build octave-cli \\\n"
"  --with-c-toolchain=fftw=gcc-toolchain@@10 \\\n"
"  --with-c-toolchain=fftwf=gcc-toolchain@@10\n"
msgstr ""
"guix build octave-cli \\\n"
"  --with-c-toolchain=fftw=gcc-toolchain@@10 \\\n"
"  --with-c-toolchain=fftwf=gcc-toolchain@@10\n"

msgid ""
"guix build --with-c-toolchain=hwloc=clang-toolchain \\\n"
"           intel-mpi-benchmarks\n"
msgstr ""
"guix build --with-c-toolchain=hwloc=clang-toolchain \\\n"
"           intel-mpi-benchmarks\n"

msgid ""
"guix build python-numpy \\\n"
"  --with-git-url=python=https://github.com/python/cpython\n"
msgstr ""
"guix build python-numpy \\\n"
"  --with-git-url=python=https://github.com/python/cpython\n"

msgid "guix build --with-branch=guile-sqlite3=master cuirass\n"
msgstr "guix build --with-branch=guile-sqlite3=master cuirass\n"

msgid "guix build coreutils --with-patch=glibc=./glibc-frob.patch\n"
msgstr "guix build coreutils --with-patch=glibc=./glibc-frob.patch\n"

msgid "guix build hello --with-configure-flag=hello=--disable-nls\n"
msgstr "guix build hello --with-configure-flag=hello=--disable-nls\n"

msgid ""
"guix build lapack \\\n"
"  --with-configure-flag=lapack=-DBUILD_SHARED_LIBS=OFF\n"
msgstr ""
"guix build lapack \\\n"
"  --with-configure-flag=lapack=-DBUILD_SHARED_LIBS=OFF\n"

msgid "guix build guix --with-latest=guile-json\n"
msgstr "guix build guix --with-latest=guile-json\n"

msgid "guix shell python python-scipy --with-version=python-numpy=1.22.4\n"
msgstr "guix shell python python-scipy --with-version=python-numpy=1.22.4\n"

msgid "guix install --without-tests=python python-notebook\n"
msgstr "guix install --without-tests=python python-notebook\n"

msgid "guix build -D hello guile\n"
msgstr "guix build -D hello guile\n"

msgid "guix build --dependents libgit2\n"
msgstr "guix build --dependents libgit2\n"

msgid "guix build -P1 python-numpy\n"
msgstr "guix build -P1 python-numpy\n"

msgid "package"
msgstr "package"

msgid ""
"$ guix build --sources tzdata\n"
"The following derivations will be built:\n"
"   /gnu/store/@dots{}-tzdata2015b.tar.gz.drv\n"
"   /gnu/store/@dots{}-tzcode2015b.tar.gz.drv\n"
msgstr ""
"$ guix build --sources tzdata\n"
"将构建以下派生：\n"
"   /gnu/store/@dots{}-tzdata2015b.tar.gz.drv\n"
"   /gnu/store/@dots{}-tzcode2015b.tar.gz.drv\n"

msgid ""
"$ guix build --sources=transitive tzdata\n"
"The following derivations will be built:\n"
"   /gnu/store/@dots{}-tzcode2015b.tar.gz.drv\n"
"   /gnu/store/@dots{}-findutils-4.4.2.tar.xz.drv\n"
"   /gnu/store/@dots{}-grep-2.21.tar.xz.drv\n"
"   /gnu/store/@dots{}-coreutils-8.23.tar.xz.drv\n"
"   /gnu/store/@dots{}-make-4.1.tar.xz.drv\n"
"   /gnu/store/@dots{}-bash-4.3.tar.xz.drv\n"
"@dots{}\n"
msgstr ""
"$ guix build --sources=transitive tzdata\n"
"将构建以下派生：\n"
"   /gnu/store/@dots{}-tzcode2015b.tar.gz.drv\n"
"   /gnu/store/@dots{}-findutils-4.4.2.tar.xz.drv\n"
"   /gnu/store/@dots{}-grep-2.21.tar.xz.drv\n"
"   /gnu/store/@dots{}-coreutils-8.23.tar.xz.drv\n"
"   /gnu/store/@dots{}-make-4.1.tar.xz.drv\n"
"   /gnu/store/@dots{}-bash-4.3.tar.xz.drv\n"
"@dots{}\n"

msgid ""
"guix build --log-file $(guix build -d guile)\n"
"guix build --log-file $(guix build guile)\n"
"guix build --log-file guile\n"
"guix build --log-file -e '(@@ (gnu packages guile) guile-2.0)'\n"
msgstr ""
"—guix build --log-file $(guix build -d guile)\n"
"guix build --log-file $(guix build guile)\n"
"guix build --log-file guile\n"
"guix build --log-file -e '(@@ (gnu packages guile) guile-2.0)'\n"

msgid ""
"$ guix build --log-file gdb -s aarch64-linux\n"
"https://@value{SUBSTITUTE-SERVER-1}/log/@dots{}-gdb-7.10\n"
msgstr ""
"$ guix build --log-file gdb -s aarch64-linux\n"
"https://@value{SUBSTITUTE-SERVER-1}/log/@dots{}-gdb-7.10\n"

msgid ""
"$ guix build foo -K\n"
"@dots{} @i{build fails}\n"
"$ cd /tmp/guix-build-foo.drv-0\n"
"$ source ./environment-variables\n"
"$ cd foo-1.2\n"
msgstr ""
"$ guix build foo -K\n"
"@dots{} @i{构建失败}\n"
"$ cd /tmp/guix-build-foo.drv-0\n"
"$ source ./environment-variables\n"
"$ cd foo-1.2\n"

msgid ""
"$ guix build -K foo\n"
"@dots{}\n"
"$ cd /tmp/guix-build-foo.drv-0\n"
"$ guix shell --no-grafts -C -D foo strace gdb\n"
"[env]# source ./environment-variables\n"
"[env]# cd foo-1.2\n"
msgstr ""
"$ guix build -K foo\n"
"@dots{}\n"
"$ cd /tmp/guix-build-foo.drv-0\n"
"$ guix shell --no-grafts -C -D foo strace gdb\n"
"[env]# source ./environment-variables\n"
"[env]# cd foo-1.2\n"

msgid "[env]# rm /bin/sh\n"
msgstr "[env]# rm /bin/sh\n"

msgid "[env]# $GUIX_ENVIRONMENT/bin/strace -f -o log make check\n"
msgstr "[env]# $GUIX_ENVIRONMENT/bin/strace -f -o log make check\n"

msgid "Invoking @command{guix edit}"
msgstr "调用 @command{guix edit}"

msgid "So many packages, so many source files! The @command{guix edit} command facilitates the life of users and packagers by pointing their editor at the source file containing the definition of the specified packages.  For instance:"
msgstr "包山包海！@command{guix edit} 命令为您开启绿色通道——只需指定软件包名，编辑器将直达其定义源码。例如："

msgid "guix edit gcc@@4.9 vim\n"
msgstr "guix edit gcc@@4.9 vim\n"

msgid "launches the program specified in the @env{VISUAL} or in the @env{EDITOR} environment variable to view the recipe of GCC@tie{}4.9.3 and that of Vim."
msgstr "启动 @env{VISUAL} 或 @env{EDITOR} 环境变量指定的编辑器，直接查看 GCC@tie{}4.9.3 与 Vim 的构建配方。"

msgid "If you are using a Guix Git checkout (@pxref{Building from Git}), or have created your own packages on @env{GUIX_PACKAGE_PATH} (@pxref{Package Modules}), you will be able to edit the package recipes.  In other cases, you will be able to examine the read-only recipes for packages currently in the store."
msgstr "若您使用 Guix Git 代码库（@pxref{Building from Git}）或在 @env{GUIX_PACKAGE_PATH} 创建自定义包（@pxref{Package Modules}），即可编辑这些配方。其他情况下仅可查阅软件包存储区中的只读配方。"

msgid "Instead of @env{GUIX_PACKAGE_PATH}, the command-line option @option{--load-path=@var{directory}} (or in short @option{-L @var{directory}}) allows you to add @var{directory} to the front of the package module search path and so make your own packages visible."
msgstr "命令行选项 @option{--load-path=@var{目录}}（简写 @option{-L @var{目录}}）可替代 @env{GUIX_PACKAGE_PATH}，将指定目录添加至软件包模块搜索路径前端，使自定义包可见。"

msgid "Invoking @command{guix download}"
msgstr "调用 @command{guix download}"

msgid "guix download"
msgstr "guix download"

msgid "When writing a package definition, developers typically need to download a source tarball, compute its SHA256 hash, and write that hash in the package definition (@pxref{Defining Packages}).  The @command{guix download} tool helps with this task: it downloads a file from the given URI, adds it to the store, and prints both its file name in the store and its SHA256 hash."
msgstr "在软件包定义编写中，开发者通常需下载源码压缩包、计算其 SHA256 哈希值，并将哈希值写入定义文件（@pxref{Defining Packages}）。@command{guix download} 工具为此提供支持：从指定 URI 下载文件，将其暂存至存储区，并输出该文件在存储区的路径及 SHA256 哈希值。"

msgid "The fact that the downloaded file is added to the store saves bandwidth: when the developer eventually tries to build the newly defined package with @command{guix build}, the source tarball will not have to be downloaded again because it is already in the store.  It is also a convenient way to temporarily stash files, which may be deleted eventually (@pxref{Invoking guix gc})."
msgstr "文件存入存储区的机制可节省带宽：当开发者最终使用 @command{guix build} 构建新定义包时，源码压缩包无需重复下载，因其已存在于存储区。此机制亦为临时存储文件提供便利，这些文件最终可被垃圾回收（@pxref{Invoking guix gc}）。"

msgid "The @command{guix download} command supports the same URIs as used in package definitions.  In particular, it supports @code{mirror://} URIs.  @code{https} URIs (HTTP over TLS) are supported @emph{provided} the Guile bindings for GnuTLS are available in the user's environment; when they are not available, an error is raised.  @xref{Guile Preparations, how to install the GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile}, for more information."
msgstr "@command{guix download} 支持包定义中使用的所有 URI 类型，尤其兼容 @code{mirror://} URI。该命令支持 @code{https} URI（基于 TLS 的 HTTP），需满足用户环境中已安装 Guile 的 GnuTLS 绑定库；若未安装将报错（完整安装指南参见 @pxref{Guile Preparations, how to install the GnuTLS bindings for Guile,, gnutls-guile, GnuTLS-Guile}）。"

msgid "@command{guix download} verifies HTTPS server certificates by loading the certificates of X.509 authorities from the directory pointed to by the @env{SSL_CERT_DIR} environment variable (@pxref{X.509 Certificates}), unless @option{--no-check-certificate} is used."
msgstr "默认情况下，@command{guix download} 通过 @env{SSL_CERT_DIR} 环境变量指定目录加载 X.509 证书颁发机构的证书以验证 HTTPS 服务器凭证（@pxref{X.509 Certificates}），除非使用 @option{--no-check-certificate} 选项。"

msgid "Alternatively, @command{guix download} can also retrieve a Git repository, possibly a specific commit, tag, or branch."
msgstr "此外，@command{guix download} 亦可获取 Git 仓库，支持指定提交记录、标签或分支。"

msgid "The following options are available:"
msgstr "以下选项可用："

msgid "--hash=@var{algorithm}"
msgstr "--hash=@var{algorithm}"

msgid "-H @var{algorithm}"
msgstr "-H @var{algorithm}"

msgid "Invoking @command{guix hash}"
msgstr "调用 @command{guix hash}"

msgid "guix hash @var{option} @var{file} ...\n"
msgstr "guix hash @var{option} @var{file} ...\n"

msgid ""
"$ git clone http://example.org/foo.git\n"
"$ cd foo\n"
"$ guix hash -x --serializer=nar .\n"
msgstr ""
"$ git clone http://example.org/foo.git\n"
"$ cd foo\n"
"$ guix hash -x --serializer=nar .\n"

msgid "guix import [@var{global-options}@dots{}] @var{importer} @var{package} [@var{options}@dots{}]\n"
msgstr "guix import [@var{global-options}@dots{}] @var{importer} @var{package} [@var{options}@dots{}]\n"

msgid "guix import gnu hello\n"
msgstr "guix import gnu hello\n"

msgid "guix import pypi itsdangerous\n"
msgstr "guix import pypi itsdangerous\n"

msgid "guix import pypi itsdangerous@@1.1.0\n"
msgstr "guix import pypi itsdangerous@@1.1.0\n"

msgid "guix import gem rails\n"
msgstr "guix import gem rails\n"

msgid "guix import gem rails@@7.0.4\n"
msgstr "guix import gem rails@@7.0.4\n"

msgid "guix import minetest Jeija/mesecons\n"
msgstr "guix import minetest Jeija/mesecons\n"

msgid "guix import minetest mesecons\n"
msgstr "guix import minetest mesecons\n"

msgid "guix import cpan Acme::Boolean\n"
msgstr "guix import cpan Acme::Boolean\n"

msgid "guix import cran Cairo\n"
msgstr "guix import cran Cairo\n"

msgid "guix import cran rasterVis@@0.50.3\n"
msgstr "guix import cran rasterVis@@0.50.3\n"

msgid "guix import cran --archive=bioconductor GenomicRanges\n"
msgstr "guix import cran --archive=bioconductor GenomicRanges\n"

msgid "guix import cran --archive=git https://github.com/immunogenomics/harmony\n"
msgstr "guix import cran --archive=git https://github.com/immunogenomics/harmony\n"

msgid "guix import texlive fontspec\n"
msgstr "guix import texlive fontspec\n"

msgid ""
"@{\n"
"  \"name\": \"hello\",\n"
"  \"version\": \"2.10\",\n"
"  \"source\": \"mirror://gnu/hello/hello-2.10.tar.gz\",\n"
"  \"build-system\": \"gnu\",\n"
"  \"home-page\": \"https://www.gnu.org/software/hello/\",\n"
"  \"synopsis\": \"Hello, GNU world: An example GNU package\",\n"
"  \"description\": \"GNU Hello prints a greeting.\",\n"
"  \"license\": \"GPL-3.0+\",\n"
"  \"native-inputs\": [\"gettext\"]\n"
"@}\n"
msgstr ""
"@{\n"
"  \"name\": \"hello\",\n"
"  \"version\": \"2.10\",\n"
"  \"source\": \"mirror://gnu/hello/hello-2.10.tar.gz\",\n"
"  \"build-system\": \"gnu\",\n"
"  \"home-page\": \"https://www.gnu.org/software/hello/\",\n"
"  \"synopsis\": \"Hello, GNU world: An example GNU package\",\n"
"  \"description\": \"GNU Hello prints a greeting.\",\n"
"  \"license\": \"GPL-3.0+\",\n"
"  \"native-inputs\": [\"gettext\"]\n"
"@}\n"

msgid ""
"@{\n"
"  @dots{}\n"
"  \"source\": @{\n"
"    \"method\": \"url-fetch\",\n"
"    \"uri\": \"mirror://gnu/hello/hello-2.10.tar.gz\",\n"
"    \"sha256\": @{\n"
"      \"base32\": \"0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i\"\n"
"    @}\n"
"  @}\n"
"  @dots{}\n"
"@}\n"
msgstr ""
"@{\n"
"  @dots{}\n"
"  \"source\": @{\n"
"    \"method\": \"url-fetch\",\n"
"    \"uri\": \"mirror://gnu/hello/hello-2.10.tar.gz\",\n"
"    \"sha256\": @{\n"
"      \"base32\": \"0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i\"\n"
"    @}\n"
"  @}\n"
"  @dots{}\n"
"@}\n"

msgid "guix import json hello.json\n"
msgstr "guix import json hello.json\n"

msgid "guix import hackage -t -e \"'((\\\"network-uri\\\" . false))\" HTTP\n"
msgstr "guix import hackage -t -e \"'((\\\"network-uri\\\" . false))\" HTTP\n"

msgid "guix import hackage mtl@@2.1.3.1\n"
msgstr "guix import hackage mtl@@2.1.3.1\n"

msgid "guix import stackage --lts-version=7.18 HTTP\n"
msgstr "guix import stackage --lts-version=7.18 HTTP\n"

msgid "guix import crate blake2-rfc\n"
msgstr "guix import crate blake2-rfc\n"

msgid "guix import crate constant-time-eq@@0.1.0\n"
msgstr "guix import crate constant-time-eq@@0.1.0\n"

msgid "guix import elm elm-explorations/webgl\n"
msgstr "guix import elm elm-explorations/webgl\n"

msgid "guix import elm elm-explorations/webgl@@1.1.3\n"
msgstr "guix import elm elm-explorations/webgl@@1.1.3\n"

msgid "guix import npm-binary buffer-crc32\n"
msgstr "guix import npm-binary buffer-crc32\n"

msgid "guix import npm-binary buffer-crc32@@1.0.0\n"
msgstr "guix import npm-binary buffer-crc32@@1.0.0\n"

msgid "guix import composer phpunit/phpunit\n"
msgstr "guix import composer phpunit/phpunit\n"

msgid "guix import go gopkg.in/yaml.v2\n"
msgstr "guix import go gopkg.in/yaml.v2\n"

msgid "guix import egg sourcehut\n"
msgstr "guix import egg sourcehut\n"

msgid "guix import egg arrays@@1.0\n"
msgstr "guix import egg arrays@@1.0\n"

msgid "guix import hexpm stun\n"
msgstr "guix import hexpm stun\n"

msgid "guix import hexpm cf@@0.3.0\n"
msgstr "guix import hexpm cf@@0.3.0\n"

msgid "Invoking @command{guix refresh}"
msgstr "调用 @command{guix refresh}"

msgid ""
"$ guix refresh\n"
"gnu/packages/gettext.scm:29:13: gettext would be upgraded from 0.18.1.1 to 0.18.2.1\n"
"gnu/packages/glib.scm:77:12: glib would be upgraded from 2.34.3 to 2.37.0\n"
msgstr ""
"$ guix refresh\n"
"gnu/packages/gettext.scm:29:13: gettext would be upgraded from 0.18.1.1 to 0.18.2.1\n"
"gnu/packages/glib.scm:77:12: glib would be upgraded from 2.34.3 to 2.37.0\n"

msgid ""
"$ guix refresh coreutils guile guile-ssh\n"
"gnu/packages/ssh.scm:205:2: warning: no updater for guile-ssh\n"
"gnu/packages/guile.scm:136:12: guile would be upgraded from 2.0.12 to 2.0.13\n"
msgstr ""
"$ guix refresh coreutils guile guile-ssh\n"
"gnu/packages/ssh.scm:205:2: warning: no updater for guile-ssh\n"
"gnu/packages/guile.scm:136:12: guile would be upgraded from 2.0.12 to 2.0.13\n"

msgid "partial target version, guix refresh"
msgstr "部分目标版本，guix refresh"

msgid "The @option{--target-version} option accepts partial version prefixes, which can be useful to update to the latest major or major-minor prefixed version:"
msgstr "@option{--target-version} 选项接受部分版本前缀，这在更新到最新的主版本或主次版本时非常有用："

msgid ""
"$ ./pre-inst-env guix refresh -u \\\n"
"       $(guix package --list-installed | cut -f1)\n"
msgstr ""
"$ ./pre-inst-env guix refresh -u \\\n"
"       $(guix package --list-installed | cut -f1)\n"

msgid ""
"$ guix refresh --recursive coreutils\n"
"gnu/packages/acl.scm:40:13: acl would be upgraded from 2.2.53 to 2.3.1\n"
"gnu/packages/m4.scm:30:12: 1.4.18 is already the latest version of m4\n"
"gnu/packages/xml.scm:68:2: warning: no updater for expat\n"
"gnu/packages/multiprecision.scm:40:12: 6.1.2 is already the latest version of gmp\n"
"@dots{}\n"
msgstr ""
"$ guix refresh --recursive coreutils\n"
"gnu/packages/acl.scm:40:13: acl would be upgraded from 2.2.53 to 2.3.1\n"
"gnu/packages/m4.scm:30:12: 1.4.18 is already the latest version of m4\n"
"gnu/packages/xml.scm:68:2: warning: no updater for expat\n"
"gnu/packages/multiprecision.scm:40:12: 6.1.2 is already the latest version of gmp\n"
"@dots{}\n"

msgid "guix refresh -l -e '(@@@@ (gnu packages commencement) glibc-final)'\n"
msgstr "guix refresh -l -e '(@@@@ (gnu packages commencement) glibc-final)'\n"

msgid "./pre-inst-env guix refresh -s non-core -u\n"
msgstr "./pre-inst-env guix refresh -s non-core -u\n"

msgid "guix refresh -L /path/to/channel -u @var{package}\n"
msgstr "guix refresh -L /path/to/channel -u @var{package}\n"

msgid ""
"$ guix refresh --type=elpa,cran\n"
"gnu/packages/statistics.scm:819:13: r-testthat would be upgraded from 0.10.0 to 0.11.0\n"
"gnu/packages/emacs.scm:856:13: emacs-auctex would be upgraded from 11.88.6 to 11.88.9\n"
msgstr ""
"$ guix refresh --type=elpa,cran\n"
"gnu/packages/statistics.scm:819:13: r-testthat would be upgraded from 0.10.0 to 0.11.0\n"
"gnu/packages/emacs.scm:856:13: emacs-auctex would be upgraded from 11.88.6 to 11.88.9\n"

msgid ""
"$ guix refresh --list-dependent flex\n"
"Building the following 120 packages would ensure 213 dependent packages are rebuilt:\n"
"hop@@2.4.0 emacs-geiser@@0.13 notmuch@@0.18 mu@@0.9.9.5 cflow@@1.4 idutils@@4.6 @dots{}\n"
msgstr ""
"$ guix refresh --list-dependent flex\n"
"Building the following 120 packages would ensure 213 dependent packages are rebuilt:\n"
"hop@@2.4.0 emacs-geiser@@0.13 notmuch@@0.18 mu@@0.9.9.5 cflow@@1.4 idutils@@4.6 @dots{}\n"

msgid ""
"$ guix refresh --list-transitive flex\n"
"flex@@2.6.4 depends on the following 25 packages: perl@@5.28.0 help2man@@1.47.6\n"
"bison@@3.0.5 indent@@2.2.10 tar@@1.30 gzip@@1.9 bzip2@@1.0.6 xz@@5.2.4 file@@5.33 @dots{}\n"
msgstr ""
"$ guix refresh --list-transitive flex\n"
"flex@@2.6.4 依赖以下 25 个软件包：perl@@5.28.0 help2man@@1.47.6\n"
"bison@@3.0.5 indent@@2.2.10 tar@@1.30 gzip@@1.9 bzip2@@1.0.6 xz@@5.2.4 file@@5.33 @dots{}\n"

msgid "You can fetch keys to a specific keybox file like this:"
msgstr "您可这样将密钥提取到特定的 keybox 文件："

msgid ""
"gpg --no-default-keyring --keyring mykeyring.kbx \\\n"
"  --recv-keys @value{OPENPGP-SIGNING-KEY-ID}\n"
msgstr ""
"gpg --no-default-keyring --keyring mykeyring.kbx \\\n"
"  --recv-keys @value{OPENPGP-SIGNING-KEY-ID}\n"

msgid "When a package signed with an unknown OpenPGP key is encountered, ask the user whether to download it or not."
msgstr "当遇到使用未知 OpenPGP 密钥签名的软件包时，询问用户是否下载。"

msgid "auto"
msgstr "auto"

msgid "Automatically selects the @code{interactive} policy when the standard input is connected to a pseudo terminal (TTY), else @code{always}.  This is the default behavior."
msgstr "当标准输入连接到伪终端（TTY）时，自动选择 @code{interactive} 策略，否则选择 @code{always}。这是默认行为。"

msgid "Invoking @command{guix style}"
msgstr "调用 @command{guix style}"

msgid "guix style"
msgstr "guix style"

msgid "guix style [@var{options}] @var{package}@dots{}\n"
msgstr "guix style [@var{options}] @var{package}@dots{}\n"

msgid "guix style --whole-file @var{file}@dots{}\n"
msgstr "guix style --whole-file @var{file}@dots{}\n"

msgid "guix style -f /etc/config.scm\n"
msgstr "guix style -f /etc/config.scm\n"

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

msgid "inputs"
msgstr "inputs"

msgid "guix style -L ~/my/channel -S inputs whatnot\n"
msgstr "guix style -L ~/my/channel -S inputs whatnot\n"

msgid "guix style -e '(@@ (gnu packages gcc) gcc-5)'\n"
msgstr "guix style -e '(@@ (gnu packages gcc) gcc-5)'\n"

msgid "Invoking @command{guix lint}"
msgstr "调用 @command{guix lint}"

msgid "guix lint @var{options} @var{package}@dots{}\n"
msgstr "guix lint @var{options} @var{package}@dots{}\n"

msgid "guix lint -c archival -e '(@@ (gnu packages guile) guile-3.0)'\n"
msgstr "guix lint -c archival -e '(@@ (gnu packages guile) guile-3.0)'\n"

msgid "Invoking @command{guix size}"
msgstr "调用 @command{guix size}"

msgid "$ guix gc -R /gnu/store/@dots{}-coreutils-8.23\n"
msgstr "$ guix gc -R /gnu/store/@dots{}-coreutils-8.23\n"

msgid "guix size $(guix system build config.scm)\n"
msgstr "guix size $(guix system build config.scm)\n"

msgid "self"
msgstr "self"

msgid "Invoking @command{guix graph}"
msgstr "调用 @command{guix graph}"

msgid "guix graph @var{options} @var{package}@dots{}\n"
msgstr "guix graph @var{options} @var{package}@dots{}\n"

msgid "guix graph coreutils | dot -Tpdf > dag.pdf\n"
msgstr "guix graph coreutils | dot -Tpdf > dag.pdf\n"

msgid "guix graph coreutils | xdot -\n"
msgstr "guix graph coreutils | xdot -\n"

msgid "guix graph --type=reverse-package ocaml\n"
msgstr "guix graph --type=reverse-package ocaml\n"

msgid "guix graph --type=bag-emerged coreutils\n"
msgstr "guix graph --type=bag-emerged coreutils\n"

msgid "guix graph -t reverse-bag dune\n"
msgstr "guix graph -t reverse-bag dune\n"

msgid "guix graph -t derivation $(guix system build -d my-config.scm)\n"
msgstr "guix graph -t derivation $(guix system build -d my-config.scm)\n"

msgid "guix graph -t module guile | xdot -\n"
msgstr "guix graph -t module guile | xdot -\n"

msgid "guix graph -t references $(readlink -f ~/.guix-profile)\n"
msgstr "guix graph -t references $(readlink -f ~/.guix-profile)\n"

msgid ""
"$ guix graph --path emacs libunistring\n"
"emacs@@26.3\n"
"mailutils@@3.9\n"
"libunistring@@0.9.10\n"
"$ guix graph --path -t derivation emacs libunistring\n"
"/gnu/store/@dots{}-emacs-26.3.drv\n"
"/gnu/store/@dots{}-mailutils-3.9.drv\n"
"/gnu/store/@dots{}-libunistring-0.9.10.drv\n"
"$ guix graph --path -t references emacs libunistring\n"
"/gnu/store/@dots{}-emacs-26.3\n"
"/gnu/store/@dots{}-libidn2-2.2.0\n"
"/gnu/store/@dots{}-libunistring-0.9.10\n"
msgstr ""
"$ guix graph --path emacs libunistring\n"
"emacs@@26.3\n"
"mailutils@@3.9\n"
"libunistring@@0.9.10\n"
"$ guix graph --path -t derivation emacs libunistring\n"
"/gnu/store/@dots{}-emacs-26.3.drv\n"
"/gnu/store/@dots{}-mailutils-3.9.drv\n"
"/gnu/store/@dots{}-libunistring-0.9.10.drv\n"
"$ guix graph --path -t references emacs libunistring\n"
"/gnu/store/@dots{}-emacs-26.3\n"
"/gnu/store/@dots{}-libidn2-2.2.0\n"
"/gnu/store/@dots{}-libunistring-0.9.10\n"

msgid "guix graph -M 2 libreoffice | xdot -f fdp -\n"
msgstr "guix graph -M 2 libreoffice | xdot -f fdp -\n"

msgid ""
"$ guix graph --path -t references libreoffice llvm\n"
"/gnu/store/@dots{}-libreoffice-6.4.2.2\n"
"/gnu/store/@dots{}-libepoxy-1.5.4\n"
"/gnu/store/@dots{}-mesa-19.3.4\n"
"/gnu/store/@dots{}-llvm-9.0.1\n"
msgstr ""
"$ guix graph --path -t references libreoffice llvm\n"
"/gnu/store/@dots{}-libreoffice-6.4.2.2\n"
"/gnu/store/@dots{}-libepoxy-1.5.4\n"
"/gnu/store/@dots{}-mesa-19.3.4\n"
"/gnu/store/@dots{}-llvm-9.0.1\n"

msgid "guix graph -e '(@@@@ (gnu packages commencement) gnu-make-final)'\n"
msgstr "guix graph -e '(@@@@ (gnu packages commencement) gnu-make-final)'\n"

msgid "guix graph git --with-input=openssl=libressl\n"
msgstr "guix graph git --with-input=openssl=libressl\n"

msgid "Invoking @command{guix publish}"
msgstr "调用 @command{guix publish}"

msgid "guix publish @var{options}@dots{}\n"
msgstr "guix publish @var{options}@dots{}\n"

msgid "guix publish\n"
msgstr "guix publish\n"

msgid "http://example.org/file/hello-2.10.tar.gz/sha256/0ssi1@dots{}ndq1i\n"
msgstr "http://example.org/file/hello-2.10.tar.gz/sha256/0ssi1@dots{}ndq1i\n"

msgid "http://example.org/log/gwspk@dots{}-guile-2.2.3\n"
msgstr "http://example.org/log/gwspk@dots{}-guile-2.2.3\n"

msgid ""
"# ln -s ~root/.guix-profile/lib/systemd/system/guix-publish.service \\\n"
"        /etc/systemd/system/\n"
"# systemctl start guix-publish && systemctl enable guix-publish\n"
msgstr ""
"# ln -s ~root/.guix-profile/lib/systemd/system/guix-publish.service \\\n"
"        /etc/systemd/system/\n"
"# systemctl start guix-publish && systemctl enable guix-publish\n"

msgid "If your host distro uses the Upstart init system:"
msgstr "如果你的主机的发行版使用 Upstart init 系统："

msgid ""
"# ln -s ~root/.guix-profile/lib/upstart/system/guix-publish.conf /etc/init/\n"
"# start guix-publish\n"
msgstr ""
"# ln -s ~root/.guix-profile/lib/upstart/system/guix-publish.conf /etc/init/\n"
"# start guix-publish\n"

msgid "Invoking @command{guix challenge}"
msgstr "调用 @command{guix challenge}"

msgid ""
"@dots{}\n"
"\n"
msgstr ""
"@dots{}\n"
"\n"

msgid ""
"guix challenge git \\\n"
"  --diff=diffoscope \\\n"
"  --substitute-urls=\"https://@value{SUBSTITUTE-SERVER-1} https://guix.example.org\"\n"
msgstr ""
"guix challenge git \\\n"
"  --diff=diffoscope \\\n"
"  --substitute-urls=\"https://@value{SUBSTITUTE-SERVER-1} https://guix.example.org\"\n"

msgid ""
"$ wget -q -O - https://@value{SUBSTITUTE-SERVER-1}/nar/lzip/@dots{}-git-2.5.0 \\\n"
"   | lzip -d | guix archive -x /tmp/git\n"
"$ diff -ur --no-dereference /gnu/store/@dots{}-git.2.5.0 /tmp/git\n"
msgstr ""
"$ wget -q -O - https://@value{SUBSTITUTE-SERVER-1}/nar/lzip/@dots{}-git-2.5.0 \\\n"
"   | lzip -d | guix archive -x /tmp/git\n"
"$ diff -ur --no-dereference /gnu/store/@dots{}-git.2.5.0 /tmp/git\n"

msgid "guix challenge @var{package}\n"
msgstr "guix challenge @var{package}\n"

msgid "guix challenge @var{options} @var{argument}@dots{}\n"
msgstr "guix challenge @var{options} @var{argument}@dots{}\n"

msgid "Invoking @command{guix copy}"
msgstr "调用 @command{guix copy}"

msgid "guix copy"
msgstr "guix copy"

msgid ""
"guix copy --to=@var{user}@@@var{host} \\\n"
"          coreutils $(readlink -f ~/.guix-profile)\n"
msgstr ""
"guix copy --to=@var{user}@@@var{host} \\\n"
"          coreutils $(readlink -f ~/.guix-profile)\n"

msgid "guix copy --from=@var{host} libreoffice gimp\n"
msgstr "guix copy --from=@var{host} libreoffice gimp\n"

msgid "guix copy [--to=@var{spec}|--from=@var{spec}] @var{items}@dots{}\n"
msgstr "guix copy [--to=@var{spec}|--from=@var{spec}] @var{items}@dots{}\n"

msgid "Invoking @command{guix container}"
msgstr "调用 @command{guix container}"

msgid "guix container @var{action} @var{options}@dots{}\n"
msgstr "guix container @var{action} @var{options}@dots{}\n"

msgid "guix container exec @var{pid} @var{program} @var{arguments}@dots{}\n"
msgstr "guix container exec @var{pid} @var{program} @var{arguments}@dots{}\n"

msgid "guix container exec 9001 /run/current-system/profile/bin/bash --login\n"
msgstr "—guix container exec 9001 /run/current-system/profile/bin/bash --login\n"

msgid "Invoking @command{guix weather}"
msgstr "调用 @command{guix weather}"

msgid "guix weather"
msgstr "guix weather"

msgid "guix weather @var{options}@dots{} [@var{packages}@dots{}]\n"
msgstr "guix weather @var{options}@dots{} [@var{packages}@dots{}]\n"

msgid "guix weather -e '(@@@@ (gnu packages rust) rust-bootstrap)'\n"
msgstr "guix weather -e '(@@@@ (gnu packages rust) rust-bootstrap)'\n"

msgid "Invoking @command{guix processes}"
msgstr "调用 @command{guix processes}"

msgid "guix processes"
msgstr "guix processes"

msgid ""
"$ guix processes --format=normalized | \\\n"
"    recsel \\\n"
"    -j Session \\\n"
"    -t ChildProcess \\\n"
"    -p Session.PID,PID \\\n"
"    -e 'Session.ClientCommand ~ \"guix build\"'\n"
"PID: 4435\n"
"Session_PID: 4278\n"
"\n"
msgstr ""
"$ guix processes --format=normalized | \\\n"
"    recsel \\\n"
"    -j Session \\\n"
"    -t ChildProcess \\\n"
"    -p Session.PID,PID \\\n"
"    -e 'Session.ClientCommand ~ \"guix build\"'\n"
"PID: 4435\n"
"Session_PID: 4278\n"
"\n"

msgid ""
"PID: 4554\n"
"Session_PID: 4278\n"
"\n"
msgstr ""
"PID: 4554\n"
"Session_PID: 4278\n"
"\n"

msgid ""
"PID: 4646\n"
"Session_PID: 4278\n"
msgstr ""
"PID: 4646\n"
"Session_PID: 4278\n"

msgid ""
"$ guix build --list-targets\n"
"The available targets are:\n"
"\n"
msgstr ""
"$ guix build --list-targets\n"
"可用的目标有：\n"
"\n"

msgid ""
"   - aarch64-linux-gnu\n"
"   - arm-linux-gnueabihf\n"
"   - avr\n"
"   - i586-pc-gnu\n"
"   - i686-linux-gnu\n"
"   - i686-w64-mingw32\n"
"   - loongarch64-linux-gnu\n"
"   - mips64el-linux-gnu\n"
"   - or1k-elf\n"
"   - powerpc-linux-gnu\n"
"   - powerpc64le-linux-gnu\n"
"   - riscv64-linux-gnu\n"
"   - x86_64-linux-gnu\n"
"   - x86_64-linux-gnux32\n"
"   - x86_64-w64-mingw32\n"
"   - xtensa-ath9k-elf\n"
msgstr ""
"   - aarch64-linux-gnu\n"
"   - arm-linux-gnueabihf\n"
"   - avr\n"
"   - i586-pc-gnu\n"
"   - i686-linux-gnu\n"
"   - i686-w64-mingw32\n"
"   - loongarch64-linux-gnu\n"
"   - mips64el-linux-gnu\n"
"   - or1k-elf\n"
"   - powerpc-linux-gnu\n"
"   - powerpc64le-linux-gnu\n"
"   - riscv64-linux-gnu\n"
"   - x86_64-linux-gnu\n"
"   - x86_64-linux-gnux32\n"
"   - x86_64-w64-mingw32\n"
"   - xtensa-ath9k-elf\n"

msgid ""
"$ guix build --target=aarch64-linux-gnu hello\n"
"/gnu/store/9926by9qrxa91ijkhw9ndgwp4bn24g9h-hello-2.12\n"
"\n"
msgstr ""
"$ guix build --target=aarch64-linux-gnu hello\n"
"/gnu/store/9926by9qrxa91ijkhw9ndgwp4bn24g9h-hello-2.12\n"
"\n"

msgid ""
"$ file /gnu/store/9926by9qrxa91ijkhw9ndgwp4bn24g9h-hello-2.12/bin/hello\n"
"/gnu/store/9926by9qrxa91ijkhw9ndgwp4bn24g9h-hello-2.12/bin/hello: ELF\n"
"64-bit LSB executable, ARM aarch64 @dots{}\n"
msgstr ""
"$ file /gnu/store/9926by9qrxa91ijkhw9ndgwp4bn24g9h-hello-2.12/bin/hello\n"
"/gnu/store/9926by9qrxa91ijkhw9ndgwp4bn24g9h-hello-2.12/bin/hello: ELF\n"
"64-bit LSB executable, ARM aarch64 @dots{}\n"

msgid ""
"$ guix build --list-systems\n"
"The available systems are:\n"
"\n"
msgstr ""
"$ guix build --list-systems\n"
"可用的系统有：\n"
"\n"

msgid ""
"   - x86_64-linux [current]\n"
"   - aarch64-linux\n"
"   - armhf-linux\n"
"   - i586-gnu\n"
"   - i686-linux\n"
"   - mips64el-linux\n"
"   - powerpc-linux\n"
"   - powerpc64le-linux\n"
"   - riscv64-linux\n"
"\n"
msgstr ""
"   - x86_64-linux [current]\n"
"   - aarch64-linux\n"
"   - armhf-linux\n"
"   - i586-gnu\n"
"   - i686-linux\n"
"   - mips64el-linux\n"
"   - powerpc-linux\n"
"   - powerpc64le-linux\n"
"   - riscv64-linux\n"
"\n"

msgid ""
"$ guix build --system=i686-linux hello\n"
"/gnu/store/cc0km35s8x2z4pmwkrqqjx46i8b1i3gm-hello-2.12\n"
"\n"
msgstr ""
"$ guix build --system=i686-linux hello\n"
"/gnu/store/cc0km35s8x2z4pmwkrqqjx46i8b1i3gm-hello-2.12\n"
"\n"

msgid ""
"$ file /gnu/store/cc0km35s8x2z4pmwkrqqjx46i8b1i3gm-hello-2.12/bin/hello\n"
"/gnu/store/cc0km35s8x2z4pmwkrqqjx46i8b1i3gm-hello-2.12/bin/hello: ELF\n"
"32-bit LSB executable, Intel 80386 @dots{}\n"
msgstr ""
"$ file /gnu/store/cc0km35s8x2z4pmwkrqqjx46i8b1i3gm-hello-2.12/bin/hello\n"
"/gnu/store/cc0km35s8x2z4pmwkrqqjx46i8b1i3gm-hello-2.12/bin/hello: ELF\n"
"32-bit LSB executable, Intel 80386 @dots{}\n"

msgid ""
"$ guix build --system=armhf-linux hello --check\n"
"/gnu/store/13xz4nghg39wpymivlwghy08yzj97hlj-hello-2.12\n"
msgstr ""
"$ guix build --system=armhf-linux hello --check\n"
"/gnu/store/13xz4nghg39wpymivlwghy08yzj97hlj-hello-2.12\n"

msgid "guix system vm /etc/config.scm\n"
msgstr "guix system vm /etc/config.scm\n"

msgid "/gnu/store/@dots{}-run-vm.sh\n"
msgstr "/gnu/store/@dots{}-run-vm.sh\n"

msgid "sudo herd restart sshd\n"
msgstr "sudo herd restart sshd\n"

msgid "sudo herd status\n"
msgstr "sudo herd status\n"

msgid "sudo herd status sshd\n"
msgstr "sudo herd status sshd\n"

msgid "guix system describe\n"
msgstr "guix system describe\n"

msgid "guix system list-generations\n"
msgstr "guix system list-generations\n"

msgid "sudo guix system roll-back\n"
msgstr "sudo guix system roll-back\n"

msgid "sudo guix system delete-generations 4m\n"
msgstr "sudo guix system delete-generations 4m\n"

msgid "The previous section showed the overall workflow you would follow when administering a Guix System machine (@pxref{Getting Started with the System}).  Let's now see in more detail what goes into the system configuration file."
msgstr "前文概述了管理 Guix 系统设备的基本流程（@pxref{入门}）。接下来我们将详述系统配置文件的具体配置内容。"

msgid "The operating system is configured by providing an @code{operating-system} declaration in a file that can then be passed to the @command{guix system} command (@pxref{Invoking guix system}), as we've seen before.  A simple setup, with the default Linux-Libre kernel, initial RAM disk, and a couple of system services added to those provided by default looks like this:"
msgstr "系统配置通过在某文件中定义 @code{operating-system} 声明实现，该文件可传递给 @command{guix system} 命令（@pxref{调用 guix system}），如前所述。一个采用默认 Linux-libre 内核及初始内存盘的基础配置示例，在默认服务基础上增添若干系统服务后，由以下代码构成："

msgid "operating-system"
msgstr "operating-system"

msgid "os-config-bare-bones.texi"
msgstr "os-config-bare-bones.texi"

msgid "The configuration is declarative.  It is code in the Scheme programming language; the whole @code{(operating-system @dots{})} expression produces a @dfn{record} with a number of @dfn{fields}.  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.  @xref{operating-system Reference}, for details about all the available fields."
msgstr "配置过程采用声明式语法。该代码基于 Scheme 编程语言，整个 @code{(operating-system @dots{})} 表达式将生成包含若干@dfn{字段}的@dfn{记录}（record）。上文定义的部分字段（如 @code{host-name} 与 @code{bootloader}）为必填项；而 @code{packages} 和 @code{services} 等字段可省略，此时系统将自动采用默认值。所有可用字段的完整说明详见 @xref{operating-system Reference}。"

msgid "Below we discuss the meaning of some of the most important fields."
msgstr "下文将阐释部分核心字段的深层含义。"

msgid "The configuration file is a Scheme program and you might get the syntax or semantics wrong as you get started.  Syntactic issues such as misplaced parentheses can often be identified by reformatting your file:"
msgstr "配置文件本质上是 Scheme 程序，初学者常会遇到语法或语义错误。诸如括号配对不当等语法问题，通常可通过重新排版文件定位："

msgid "guix style -f config.scm\n"
msgstr "guix style -f config.scm\n"

msgid "The Cookbook has a short section to get started with the Scheme programming language that explains the fundamentals, which you will find helpful when hacking your configuration.  @xref{A Scheme Crash Course,,, guix-cookbook, GNU Guix Cookbook}."
msgstr "《烹饪书》提供 Scheme 编程语言入门精要，阐述其基础原理。这些知识在配置开发过程中将大有裨益。@xref{Scheme 急就,,, guix-cookbook.zh_CN, GNU Guix 烹饪书}。"

msgid "Bootloader"
msgstr "引导加载器"

msgid "legacy boot, on Intel machines"
msgstr "传统引导, Intel 平台"

msgid "BIOS boot, on Intel machines"
msgstr "BIOS 引导, Intel 平台"

msgid "UEFI boot"
msgstr "UEFI 引导"

msgid "EFI boot"
msgstr "EFI 引导"

msgid "The @code{bootloader} field describes the method that will be used to boot your system.  Machines based on Intel processors can boot in ``legacy'' BIOS mode, as in the example above.  However, more recent machines rely instead on the @dfn{Unified Extensible Firmware Interface} (UEFI) to boot.  In that case, the @code{bootloader} field should contain something along these lines:"
msgstr "@code{bootloader} 字段定义系统引导方式。基于 Intel 处理器的设备可采用“传统” BIOS 模式引导（如上例所示），而现代设备通常依赖 @dfn{统一可扩展固件接口}（Unified Extensible Firmware Interface，UEFI）实现引导。此时，@code{bootloader} 字段需采用类似以下结构："

msgid ""
"(bootloader-configuration\n"
"  (bootloader grub-efi-bootloader)\n"
"  (targets '(\"/boot/efi\")))\n"
msgstr ""
"(bootloader-configuration\n"
"  (bootloader grub-efi-bootloader)\n"
"  (targets '(\"/boot/efi\")))\n"

msgid "@xref{Bootloader Configuration}, for more information on the available configuration options."
msgstr "@xref{Bootloader Configuration}，获取完整配置选项。"

msgid "Globally-Visible Packages"
msgstr "全局可见软件包"

msgid "%base-packages"
msgstr "%base-packages"

msgid "The @code{packages} field lists packages that will be globally visible on the system, for all user accounts---i.e., in every user's @env{PATH} environment variable---in addition to the per-user profiles (@pxref{Invoking guix package}).  The @code{%base-packages} variable provides all the tools one would expect for basic user and administrator tasks---including the GNU Core Utilities, the GNU Networking Utilities, the @command{mg} lightweight text editor, @command{find}, @command{grep}, etc.  The example above adds GNU@tie{}Screen to those, taken from the @code{(gnu packages screen)} module (@pxref{Package Modules}).  The @code{(list package output)} syntax can be used to add a specific output of a package:"
msgstr "@code{packages} 字段定义系统中全局可见的软件包，除各用户专属软件集外（@pxref{调用 guix package}），所有账户均可访问——即每个用户的 @env{PATH} 环境变量均包含这些软件。@code{%base-packages} 变量提供基础用户及管理任务所需的全部工具，含 GNU 核心工具集、网络工具集、轻量文本编辑器 @command{mg}、@command{find}、@command{grep} 等。上例通过 @code{(gnu packages screen)} 模块（@pxref{软件包模块}）额外添加了 GNU@tie{}Screen。采用 @code{(list package output)} 语法可添加软件包的特定输出："

msgid ""
"(use-modules (gnu packages))\n"
"(use-modules (gnu packages dns))\n"
"\n"
msgstr ""
"(use-modules (gnu packages))\n"
"(use-modules (gnu packages dns))\n"
"\n"

msgid ""
"(operating-system\n"
"  ;; ...\n"
"  (packages (cons (list isc-bind \"utils\")\n"
"                  %base-packages)))\n"
msgstr ""
"(operating-system\n"
"  ;; ...\n"
"  (packages (cons (list isc-bind \"utils\")\n"
"                  %base-packages)))\n"

msgid "specification->package"
msgstr "specification->package"

msgid "Referring to packages by variable name, like @code{isc-bind} above, has the advantage of being unambiguous; it also allows typos and such to be diagnosed right away as ``unbound variables''.  The downside is that one needs to know which module defines which package, and to augment the @code{use-package-modules} line accordingly.  To avoid that, one can use the @code{specification->package} procedure of the @code{(gnu packages)} module, which returns the best package for a given name or name and version:"
msgstr "通过变量名引用软件包（如上文的 @code{isc-bind}）优势在于明确无歧义，同时拼写错误等问题可即时诊断为“未绑定变量”。其局限在于需知晓定义各软件包的对应模块，并需相应扩展 @code{use-package-modules} 声明。若需规避此限制，可调用 @code{(gnu packages)} 模块的 @code{specification->package} 过程，该函数将根据给定名称（或名称加版本号）返回最优匹配的软件包："

msgid ""
"(use-modules (gnu packages))\n"
"\n"
msgstr ""
"(use-modules (gnu packages))\n"
"\n"

msgid ""
"(operating-system\n"
"  ;; ...\n"
"  (packages (append (map specification->package\n"
"                         '(\"tcpdump\" \"htop\" \"gnupg@@2.0\"))\n"
"                    %base-packages)))\n"
msgstr ""
"(operating-system\n"
"  ;; ...\n"
"  (packages (append (map specification->package\n"
"                         '(\"tcpdump\" \"htop\" \"gnupg@@2.0\"))\n"
"                    %base-packages)))\n"

msgid "specifications->packages"
msgstr "specifications->packages"

msgid "When a package has more than one output it can be a challenge to refer to a specific output instead of just to the standard @code{out} output.  For these situations one can use the @code{specifications->packages} procedure from the @code{(gnu packages)} module.  For example:"
msgstr "当软件包存在多输出时，精确引用特定输出（而非标准 @code{out} 输出）颇具挑战性。此类场景可借助 @code{(gnu packages)} 模块的 @code{specifications->packages} 过程实现，例如："

msgid ""
"(operating-system\n"
"  ;; ...\n"
"  (packages (append (specifications->packages\n"
"                      '(\"git\" \"git:send-email\"))\n"
"                    %base-packages)))\n"
"\n"
msgstr ""
"(operating-system\n"
"  ;; ...\n"
"  (packages (append (specifications->packages\n"
"                      '(\"git\" \"git:send-email\"))\n"
"                    %base-packages)))\n"
"\n"

msgid "System Services"
msgstr "系统服务"

msgid "services"
msgstr "服务"

msgid "%base-services"
msgstr "%base-services"

msgid "The @code{services} field lists @dfn{system services} to be made available when the system starts (@pxref{Services}).  The @code{operating-system} declaration above specifies that, in addition to the basic services, we want the OpenSSH secure shell daemon listening on port 2222 (@pxref{Networking Services, @code{openssh-service-type}}).  Under the hood, @code{openssh-service-type} arranges so that @command{sshd} is started with the right command-line options, possibly with supporting configuration files generated as needed (@pxref{Defining Services})."
msgstr "@code{services} 字段定义系统启动时启用的 @dfn{系统服务}（@pxref{服务}）。上例的 operating-system 声明表明：除基础服务外，系统需在 2222 端口监听 OpenSSH 安全 Shell 守护进程（@pxref{网络服务, @code{openssh-service-type}}）。底层实现中，@code{openssh-service-type} 确保以正确的命令行参数启动 @command{sshd}，并按需生成辅助配置文件（@pxref{定义服务}）。"

msgid "customization, of services"
msgstr "服务之自定义"

msgid "modify-services"
msgstr "modify-services"

msgid "Occasionally, instead of using the base services as is, you will want to customize them.  To do this, use @code{modify-services} (@pxref{Service Reference, @code{modify-services}}) to modify the list."
msgstr "有时您需定制而非直接使用基础服务。此时请通过 @code{modify-services} 调整服务列表（@pxref{服务参考, @code{modify-services}}）。"

msgid "auto-login to TTY"
msgstr "自动登录到 TTY"

msgid ""
"guix system shepherd-graph /etc/config.scm | \\\n"
"  guix shell xdot -- xdot -\n"
msgstr ""
"guix system shepherd-graph /etc/config.scm | \\\n"
"  guix shell xdot -- xdot -\n"

msgid ""
"guix system extension-graph /etc/config.scm | \\\n"
"  guix shell xdot -- xdot -\n"
msgstr ""
"guix system extension-graph /etc/config.scm | \\\n"
"  guix shell xdot -- xdot -\n"

msgid ""
"$ guix repl\n"
"scheme@@(guix-user)> ,use (gnu)\n"
"scheme@@(guix-user)> (define os (load \"config.scm\"))\n"
"scheme@@(guix-user)> ,pp (map service-kind (operating-system-services os))\n"
"$1 = (#<service-type localed cabba93>\n"
"      @dots{})\n"
msgstr ""
"$ guix repl\n"
"scheme@@(guix-user)> ,use (gnu)\n"
"scheme@@(guix-user)> (define os (load \"config.scm\"))\n"
"scheme@@(guix-user)> ,pp (map service-kind (operating-system-services os))\n"
"$1 = (#<service-type localed cabba93>\n"
"      @dots{})\n"

msgid "@code{operating-system} Reference"
msgstr "@code{operating-system} 参考"

msgid "bootloader"
msgstr "bootloader"

msgid "List of user accounts and groups.  @xref{User Accounts}."
msgstr "用户账户与用户组列表。 @xref{User Accounts}。"

msgid "operating-system-essential-services"
msgstr "operating-system-essential-services"

msgid "this-operating-system"
msgstr "this-operating-system"

msgid "The Btrfs has special features, such as subvolumes, that merit being explained in more details.  The following section attempts to cover basic as well as complex uses of a Btrfs file system with the Guix System."
msgstr "Btrfs 具备子卷等特殊功能，值得详细阐述。下文将涵盖 Guix 系统中 Btrfs 文件系统的基础应用与复杂场景。"

msgid "In its simplest usage, a Btrfs file system can be described, for example, by:"
msgstr "最简配置中，Btrfs 文件系统可通过如下形式定义："

msgid ""
"(file-system\n"
"  (mount-point \"/home\")\n"
"  (type \"btrfs\")\n"
"  (device (file-system-label \"my-home\")))\n"
msgstr ""
"(file-system\n"
"  (mount-point \"/home\")\n"
"  (type \"btrfs\")\n"
"  (device (file-system-label \"my-home\")))\n"

msgid "The example below is more complex, as it makes use of a Btrfs subvolume, named @code{rootfs}.  The parent Btrfs file system is labeled @code{my-btrfs-pool}, and is located on an encrypted device (hence the dependency on @code{mapped-devices}):"
msgstr "以下示例更为复杂，因其使用了名为 @code{rootfs} 的 Btrfs 子卷。父级 Btrfs 文件系统标签为 @code{my-btrfs-pool}，且位于加密设备上（故需依赖 @code{mapped-devices}）："

msgid ""
"(file-system\n"
"  (device (file-system-label \"my-btrfs-pool\"))\n"
"  (mount-point \"/\")\n"
"  (type \"btrfs\")\n"
"  (options \"subvol=rootfs\")\n"
"  (dependencies mapped-devices))\n"
msgstr ""
"(file-system\n"
"  (device (file-system-label \"my-btrfs-pool\"))\n"
"  (mount-point \"/\")\n"
"  (type \"btrfs\")\n"
"  (options \"subvol=rootfs\")\n"
"  (dependencies mapped-devices))\n"

msgid "Some bootloaders, for example GRUB, only mount a Btrfs partition at its top level during the early boot, and rely on their configuration to refer to the correct subvolume path within that top level.  The bootloaders operating in this way typically produce their configuration on a running system where the Btrfs partitions are already mounted and where the subvolume information is readily available.  As an example, @command{grub-mkconfig}, the configuration generator command shipped with GRUB, reads @file{/proc/self/mountinfo} to determine the top-level path of a subvolume."
msgstr "部分引导加载器（如 GRUB）在早期启动阶段仅挂载 Btrfs 分区的顶级目录，并依赖其配置指向该层级内的正确子卷路径。此类引导程序通常在已挂载 Btrfs 分区且子卷信息可用的运行中系统上生成配置。例如，GRUB 附带的配置生成命令 @command{grub-mkconfig} 会读取 @file{/proc/self/mountinfo} 以确定子卷的顶级路径。"

msgid "The Guix System produces a bootloader configuration using the operating system configuration as its sole input; it is therefore necessary to extract the subvolume name on which @file{/gnu/store} lives (if any)  from that operating system configuration.  To better illustrate, consider a subvolume named 'rootfs' which contains the root file system data.  In such situation, the GRUB bootloader would only see the top level of the root Btrfs partition, e.g.:"
msgstr "Guix 系统完全基于操作系统配置@footnote{原文为 “operating system configuration”。}生成引导加载器配置，因此必须从该配置中提取 @file{/gnu/store} 所在的子卷名称（若存在）。为清晰说明，假设包含根文件系统数据的子卷名为 “rootfs”。此场景中，GRUB 引导加载器仅能访问根 Btrfs 分区的顶级目录，例如："

msgid ""
"/                   (top level)\n"
"├── rootfs          (subvolume directory)\n"
"    ├── gnu         (normal directory)\n"
"        ├── store   (normal directory)\n"
"[...]\n"
msgstr ""
"/                   （顶层）\n"
"├── rootfs（子卷目录）\n"
"    ├── gnu（普通目录）\n"
"        ├── store（普通目录）\n"
"[...]\n"

msgid "Thus, the subvolume name must be prepended to the @file{/gnu/store} path of the kernel, initrd binaries and any other files referred to in the GRUB configuration that must be found during the early boot."
msgstr "因此，必须将子卷名添加至 GRUB 配置中所有需在早期启动阶段访问的文件路径前，包括内核的 @file{/gnu/store} 路径、初始化内存盘二进制文件及其他相关文件。"

msgid "The next example shows a nested hierarchy of subvolumes and directories:"
msgstr "下例展示子卷与目录的嵌套层级结构："

msgid ""
"/                   (top level)\n"
"├── rootfs          (subvolume)\n"
"    ├── gnu         (normal directory)\n"
"        ├── store   (subvolume)\n"
"[...]\n"
msgstr ""
"/                   （顶层）\n"
"├── rootfs（子卷）\n"
"    ├── gnu（普通目录）\n"
"        ├── store（子卷）\n"
"[...]\n"

msgid "This scenario would work without mounting the 'store' subvolume.  Mounting 'rootfs' is sufficient, since the subvolume name matches its intended mount point in the file system hierarchy.  Alternatively, the 'store' subvolume could be referred to by setting the @code{subvol} option to either @code{/rootfs/gnu/store} or @code{rootfs/gnu/store}."
msgstr "此场景无需挂载 “store” 子卷。挂载 “rootfs” 即可满足需求，因子卷名称与其在文件系统层级中的目标挂载点匹配。或者，可通过将 @code{subvol} 选项设为 @code{/rootfs/gnu/store} 或 @code{rootfs/gnu/store} 来引用 “store” 子卷。"

msgid "Finally, a more contrived example of nested subvolumes:"
msgstr "最后展示一个更复杂的嵌套子卷示例："

msgid ""
"/                           (top level)\n"
"├── root-snapshots          (subvolume)\n"
"    ├── root-current        (subvolume)\n"
"        ├── guix-store      (subvolume)\n"
"[...]\n"
msgstr ""
"/                           （顶层）\n"
"├── root-snapshots（子卷）\n"
"    ├── root-current（子卷）\n"
"        ├── guix-store（子卷）\n"
"[...]\n"

msgid "Here, the 'guix-store' subvolume doesn't match its intended mount point, so it is necessary to mount it.  The subvolume must be fully specified, by passing its file name to the @code{subvol} option.  To illustrate, the 'guix-store' subvolume could be mounted on @file{/gnu/store} by using a file system declaration such as:"
msgstr "此处 “guix-store” 子卷与其预期挂载点不匹配，故必须显式挂载。需通过向 @code{subvol} 选项传递完整文件名来指定该子卷。例如，可通过如下文件系统声明将 “guix-store” 子卷挂载至 @file{/gnu/store}："

msgid ""
"(file-system\n"
"  (device (file-system-label \"btrfs-pool-1\"))\n"
"  (mount-point \"/gnu/store\")\n"
"  (type \"btrfs\")\n"
"  (options \"subvol=root-snapshots/root-current/guix-store,\\\n"
"compress-force=zstd,space_cache=v2\"))\n"
msgstr ""
"(file-system\n"
"  (device (file-system-label \"btrfs-pool-1\"))\n"
"  (mount-point \"/gnu/store\")\n"
"  (type \"btrfs\")\n"
"  (options \"subvol=root-snapshots/root-current/guix-store,\\\n"
"compress-force=zstd,space_cache=v2\"))\n"

msgid "cryptsetup luksUUID /dev/sda3\n"
msgstr "cryptsetup luksUUID /dev/sda3\n"

msgid ""
"(kernel-arguments\n"
"  (cons* \"resume=/dev/mapper/my-swap\"\n"
"         %default-kernel-arguments))\n"
msgstr ""
"(kernel-arguments\n"
"  (cons* \"resume=/dev/mapper/my-swap\"\n"
"         %default-kernel-arguments))\n"

msgid "User accounts and groups are entirely managed through the @code{operating-system} declaration.  They are specified with the @code{user-account} and @code{user-group} forms:"
msgstr "用户账户与组完全通过 @code{operating-system} 声明管理，通过 @code{user-account} 和 @code{user-group} 形式指定："

msgid ""
"(user-account\n"
"  (name \"alice\")\n"
"  (group \"users\")\n"
"  (supplementary-groups '(\"wheel\"   ;allow use of sudo, etc.\n"
"                          \"audio\"   ;sound card\n"
"                          \"video\"   ;video devices such as webcams\n"
"                          \"cdrom\")) ;the good ol' CD-ROM\n"
"  (comment \"Bob's sister\"))\n"
msgstr ""
"(user-account\n"
"  (name \"HanMeimei\")\n"
"  (group \"users\")\n"
"  (supplementary-groups '(\"wheel\"   ;允许使用 sudo 等\n"
"                          \"audio\"   ;声卡\n"
"                          \"video\"   ;视频设备，如网络摄像头\n"
"                          \"cdrom\")) ;老式 CD-ROM\n"
"  (comment \"李华的同学\"))\n"

msgid "Here's a user account that uses a different shell and a custom home directory (the default would be @file{\"/home/bob\"}):"
msgstr "以下账户使用不同 Shell 和自定义主目录（默认应为 @file{“/home/LiHua”}）："

msgid ""
"(user-account\n"
"  (name \"bob\")\n"
"  (group \"users\")\n"
"  (comment \"Alice's bro\")\n"
"  (shell (file-append zsh \"/bin/zsh\"))\n"
"  (home-directory \"/home/robert\"))\n"
msgstr ""
"(user-account\n"
"  (name \"LiHua\")\n"
"  (group \"users\")\n"
"  (comment \"韩梅梅的同学\")\n"
"  (shell (file-append zsh \"/bin/zsh\"))\n"
"  (home-directory \"/home/XiaoHua\"))\n"

msgid "When booting or upon completion of @command{guix system reconfigure}, the system ensures that only the user accounts and groups specified in the @code{operating-system} declaration exist, and with the specified properties.  Thus, account or group creations or modifications made by directly invoking commands such as @command{useradd} are lost upon reconfiguration or reboot.  This ensures that the system remains exactly as declared."
msgstr "系统在启动或执行 @command{guix system reconfigure} 后，会确保仅存在 @code{operating-system} 声明中指定的用户账户和组，且属性完全匹配。因此，直接调用如 @command{useradd} 等命令创建的账户或组将在重构或重启后失效，从而确保系统状态与声明严格一致。"

msgid "{Data Type} user-account"
msgstr "{数据类型} user-account"

msgid "Objects of this type represent user accounts.  The following members may be specified:"
msgstr "该类型对象表示用户账户，可指定以下成员属性："

msgid "The name of the user account."
msgstr "用户帐户之名称。"

msgid "group"
msgstr "group"

msgid "groups"
msgstr "用户组"

msgid "This is the name (a string) or identifier (a number) of the user group this account belongs to."
msgstr "此字段指定账户所属主用户组的名称（字符串）或标识符（数字）。"

msgid "@code{supplementary-groups} (default: @code{'()})"
msgstr "@code{supplementary-groups}（默认值：@code{'()}）"

msgid "Optionally, this can be defined as a list of group names that this account belongs to."
msgstr "可选，定义为该账户所属的附加用户组名称列表。"

msgid "@code{uid} (default: @code{#f})"
msgstr "@code{uid}（默认值：@code{#f}）"

msgid "This is the user ID for this account (a number), or @code{#f}.  In the latter case, a number is automatically chosen by the system when the account is created."
msgstr "此表示账户的用户 ID（数字），或设为 @code{#f}。若为后者，系统将在创建账户时自动分配数字 ID。"

msgid "@code{comment} (default: @code{\"\"})"
msgstr "@code{comment}（默认值：@code{\"\"}）"

msgid "A comment about the account, such as the account owner's full name."
msgstr "账户备注信息（如账户持有者全名）。"

msgid "Note that, for non-system accounts, users are free to change their real name as it appears in @file{/etc/passwd} using the @command{chfn} command.  When they do, their choice prevails over the system administrator's choice; reconfiguring does @emph{not} change their name."
msgstr "需注意：对于非系统账户，用户可通过 @command{chfn} 命令自由修改 @file{/etc/passwd} 中显示的全名。用户修改后，其选择将覆盖系统管理员设置；系统重配置@emph{不会}修改该名称。"

msgid "home-directory"
msgstr "home-directory"

msgid "This is the name of the home directory for the account."
msgstr "此乃是该帐户家目录名称。"

msgid "@code{create-home-directory?} (default: @code{#t})"
msgstr "@code{create-home-directory?}（默认值：@code{#t}）"

msgid "Indicates whether the home directory of this account should be created if it does not exist yet."
msgstr "指示如果该帐户家目录尚不存在，是否应创建该家目录。"

msgid "@code{shell} (default: Bash)"
msgstr "@code{shell}（默认值：Bash）"

msgid "This is a G-expression denoting the file name of a program to be used as the shell (@pxref{G-Expressions}).  For example, you would refer to the Bash executable like this:"
msgstr "此为 G 表达式，指向用作 Shell 的程序文件名（@pxref{G-Expressions}）。例如引用 Bash 可执行文件如下："

msgid "(file-append bash \"/bin/bash\")\n"
msgstr "(file-append bash \"/bin/bash\")\n"

msgid "... and to the Zsh executable like that:"
msgstr "……引用 Zsh 可执行文件如下："

msgid "(file-append zsh \"/bin/zsh\")\n"
msgstr "(file-append zsh \"/bin/zsh\")\n"

msgid "@code{system?} (default: @code{#f})"
msgstr "@code{system?}（默认值：@code{#f}）"

msgid "This Boolean value indicates whether the account is a ``system'' account.  System accounts are sometimes treated specially; for instance, graphical login managers do not list them."
msgstr "此布尔值表示账户是否为“系统”@footnote{原词为 “system”。}账户。系统账户通常被特殊处理：例如图形登录管理器不会显示此类账户。"

msgid "user-account-password"
msgstr "user-account-password"

msgid "password, for user accounts"
msgstr "用户账户之密码"

msgid "You would normally leave this field to @code{#f}, initialize user passwords as @code{root} with the @command{passwd} command, and then let users change it with @command{passwd}.  Passwords set with @command{passwd} are of course preserved across reboot and reconfiguration."
msgstr "通常应将此字段设为 @code{#f}，由管理员通过 @command{passwd} 初始化用户密码，随后用户可自行使用 @command{passwd} 修改。通过 @command{passwd} 设置的密码在重启或重配置后永久保留。"

msgid "If you @emph{do} want to set an initial password for an account, then this field must contain the encrypted password, as a string.  You can use the @code{crypt} procedure for this purpose:"
msgstr "若@emph{需}为账户设置初始密码，该字段必须包含加密后的密码字符串。可使用 @code{crypt} 过程生成："

msgid ""
"(user-account\n"
"  (name \"charlie\")\n"
"  (group \"users\")\n"
"\n"
msgstr ""
"(user-account\n"
"  (name \"LiMing\")\n"
"  (group \"users\")\n"
"\n"

msgid ""
"  ;; Specify a SHA-512-hashed initial password.\n"
"  (password (crypt \"InitialPassword!\" \"$6$abc\")))\n"
msgstr ""
"  ;; 指定一个 SHA-512 哈希的初始密码。\n"
"  (password (crypt \"InitialPassword!\" \"$6$abc\")))\n"

msgid "The hash of this initial password will be available in a file in @file{/gnu/store}, readable by all the users, so this method must be used with care."
msgstr "此初始密码的哈希值将存储于 @file{/gnu/store} 的公开（所有用户均可读取）可读文件中，故使用时需谨慎。"

msgid "@xref{Passphrase Storage,,, libc, The GNU C Library Reference Manual}, for more information on password encryption, and @ref{Encryption,,, guile, GNU Guile Reference Manual}, for information on Guile's @code{crypt} procedure."
msgstr "密码加密机制详见 @xref{Passphrase Storage,,, libc, The GNU C Library Reference Manual}，@code{crypt} 过程说明参见 @ref{Encryption,,, guile, GNU Guile Reference Manual}。"

msgid "User group declarations are even simpler:"
msgstr "用户组声明甚至更简单："

msgid "(user-group (name \"students\"))\n"
msgstr "(user-group (name \"students\"))\n"

msgid "{Data Type} user-group"
msgstr "{数据类型} user-group"

msgid "This type is for, well, user groups.  There are just a few fields:"
msgstr "这类型嘛，专管用户组那点事儿。字段不多，就这几个："

msgid "The name of the group."
msgstr "用户组之名称。"

msgid "@code{id} (default: @code{#f})"
msgstr "@code{id} (默认值：@code{#f})"

msgid "The group identifier (a number).  If @code{#f}, a new number is automatically allocated when the group is created."
msgstr "组标识符（数字）。若设为 @code{#f}，创建组时将自动分配数字标识符。"

msgid "This Boolean value indicates whether the group is a ``system'' group.  System groups have low numerical IDs."
msgstr "布尔值，表示是否为“系统”组。系统组具有较小的数字标识符。"

msgid "What, user groups can have a password? Well, apparently yes.  Unless @code{#f}, this field specifies the password of the group."
msgstr "啥玩意儿？用户组还能设密码？对的呢！除非填 @code{#f}，否则此字段指定该组的密码。"

msgid "For convenience, a variable lists all the basic user groups one may expect:"
msgstr "为图方便，此变量列出用户可能期望的所有基础用户组："

msgid "%base-groups"
msgstr "%base-groups"

msgid "This is the list of basic user groups that users and/or packages expect to be present on the system.  This includes groups such as ``root'', ``wheel'', and ``users'', as well as groups used to control access to specific devices such as ``audio'', ``disk'', and ``cdrom''."
msgstr "此列表包含用户和（或）软件包要求系统必须存在的基础用户组。具体涵盖 “root”“wheel”“users” 等账户管理组，以及用于控制特定设备访问权限的组，如 “audio”“disk” 与 “cdrom”。"

msgid "%base-user-accounts"
msgstr "%base-user-accounts"

msgid "setxkbmap us dvorak\n"
msgstr "setxkbmap us dvorak\n"

msgid "loadkeys fr-bepo\n"
msgstr "loadkeys fr-bepo\n"

msgid "# herd status\n"
msgstr "# herd status\n"

msgid ""
"# herd doc nscd\n"
"Run libc's name service cache daemon (nscd).\n"
"\n"
msgstr ""
"# herd doc nscd\n"
"Run libc's name service cache daemon (nscd).\n"
"\n"

msgid ""
"# herd configuration sshd\n"
"/gnu/store/@dots{}-sshd_config\n"
msgstr ""
"# herd configuration sshd\n"
"/gnu/store/@dots{}-sshd_config\n"

msgid ""
"127.0.0.1 localhost @var{host-name}\n"
"::1       localhost @var{host-name}\n"
msgstr ""
"127.0.0.1 localhost @var{host-name}\n"
"::1       localhost @var{host-name}\n"

msgid "herd invalidate nscd hosts\n"
msgstr "herd invalidate nscd hosts\n"

msgid "syslog, with external syslogd"
msgstr "syslog，以及额外的 syslogd"

msgid "# herd reload syslog\n"
msgstr "# herd reload syslog\n"

msgid "herd set-http-proxy guix-daemon http://localhost:8118\n"
msgstr "herd set-http-proxy guix-daemon http://localhost:8118\n"

msgid "herd set-http-proxy guix-daemon\n"
msgstr "herd set-http-proxy guix-daemon\n"

msgid "Command to be started by @command{agreety} on successful login."
msgstr "成功登录时由 @command{agreety} 启动的命令。"

msgid "herd trigger garbage-collection\n"
msgstr "herd trigger garbage-collection\n"

msgid "# herd schedule mcron\n"
msgstr "# herd schedule mcron\n"

msgid "# herd schedule mcron 10\n"
msgstr "# herd schedule mcron 10\n"

msgid "directory"
msgstr "directory"

msgid "input"
msgstr "input"

msgid "debug?"
msgstr "debug?"

msgid "Increment the IP address by the given number.  By default this is zero."
msgstr "通过给定的数字递增 IP 地址。默认情况下，这个值为零。"

msgid ""
"ip address add 10.0.2.15/24 dev eno1\n"
"ip address add 2001:123:4567:101::1/64 dev eno1\n"
"ip route add default via inet 10.0.2.2\n"
"ip route add default via inet6 2020:321:4567:42::1\n"
msgstr ""
"ip address add 10.0.2.15/24 dev eno1\n"
"ip address add 2001:123:4567:101::1/64 dev eno1\n"
"ip route add default via inet 10.0.2.2\n"
"ip route add default via inet6 2020:321:4567:42::1\n"

msgid "destination"
msgstr "destination"

msgid ""
"nmcli connection add type tun \\\n"
" connection.interface-name tap0 \\\n"
" tun.mode tap tun.owner $(id -u) \\\n"
" ipv4.method shared \\\n"
" ipv4.addresses 172.28.112.1/24\n"
msgstr ""
"nmcli connection add type tun \\\n"
" connection.interface-name tap0 \\\n"
" tun.mode tap tun.owner $(id -u) \\\n"
" ipv4.method shared \\\n"
" ipv4.addresses 172.28.112.1/24\n"

msgid "This is the service type to set up a nftables configuration.  nftables is a netfilter project that aims to replace the iptables, ip6tables, arptables and ebtables framework.  It provides a new packet filtering framework, a new user-space utility @command{nft}, and a compatibility layer for iptables.  This service comes with a default ruleset, @code{%default-nftables-ruleset}, that rejects all incoming connections except those to the SSH port 22 (TCP).  To use it, simply write:"
msgstr "这是设置 nftables 配置的服务类型。nftables 是一个 netfilter 项目，旨在替代现有的iptables、ip6tables、arptables 和 ebtables 框架。它提供了一个新的数据包过滤框架，一个新的用户空间工具@command{nft}，以及 iptables 的兼容层。该服务附带默认规则集@code{%default-nftables-ruleset}，拒绝所有传入连接，除了 SSH 端口 22（TCP）的连接。要使用它，只需写："

msgid ""
"(ntp-server\n"
" (type 'server)\n"
" (address \"some.ntp.server.org\")\n"
" (options `(iburst (version 3) (maxpoll 16) prefer))))\n"
msgstr ""
"(ntp-server\n"
" (type 'server)\n"
" (address \"some.ntp.server.org\")\n"
" (options `(iburst (version 3) (maxpoll 16) prefer))))\n"

msgid "XMLLINT_INDENT=\"    \" xmllint --format /path/to/new/config.xml | diff /path/to/old/config.xml -\n"
msgstr "XMLLINT_INDENT=\"    \" xmllint --format /path/to/new/config.xml | diff /path/to/old/config.xml -\n"

msgid "path"
msgstr "path"

msgid ""
"(service dropbear-service-type (dropbear-configuration\n"
"                                 (port-number 1234)))\n"
msgstr ""
"(service dropbear-service-type (dropbear-configuration\n"
"                                 (port-number 1234)))\n"

msgid "avahi-browse _workstation._tcp\n"
msgstr "avahi-browse _workstation._tcp\n"

msgid ""
"(service keepalived-service-type\n"
"         (keepalived-configuration\n"
"           (config-file (local-file \"keepalived-master.conf\"))))\n"
msgstr ""
"(service keepalived-service-type\n"
"         (keepalived-configuration\n"
"           (config-file (local-file \"keepalived-master.conf\"))))\n"

msgid ""
"vrrp_instance my-group @{\n"
"  state MASTER\n"
"  interface enp9s0\n"
"  virtual_router_id 100\n"
"  priority 100\n"
"  unicast_peer @{ 10.0.0.2 @}\n"
"  virtual_ipaddress @{\n"
"    10.0.0.4/24\n"
"  @}\n"
"@}\n"
msgstr ""
"vrrp_instance my-group @{\n"
"  state MASTER\n"
"  interface enp9s0\n"
"  virtual_router_id 100\n"
"  priority 100\n"
"  unicast_peer @{ 10.0.0.2 @}\n"
"  virtual_ipaddress @{\n"
"    10.0.0.4/24\n"
"  @}\n"
"@}\n"

msgid ""
"(service keepalived-service-type\n"
"         (keepalived-configuration\n"
"          (config-file (local-file \"keepalived-backup.conf\"))))\n"
msgstr ""
"(service keepalived-service-type\n"
"         (keepalived-configuration\n"
"          (config-file (local-file \"keepalived-backup.conf\"))))\n"

msgid ""
"vrrp_instance my-group @{\n"
"  state BACKUP\n"
"  interface enp9s0\n"
"  virtual_router_id 100\n"
"  priority 99\n"
"  unicast_peer @{ 10.0.0.3 @}\n"
"  virtual_ipaddress @{\n"
"    10.0.0.4/24\n"
"  @}\n"
"@}\n"
msgstr ""
"vrrp_instance my-group @{\n"
"  state BACKUP\n"
"  interface enp9s0\n"
"  virtual_router_id 100\n"
"  priority 99\n"
"  unicast_peer @{ 10.0.0.3 @}\n"
"  virtual_ipaddress @{\n"
"    10.0.0.4/24\n"
"  @}\n"
"@}\n"

msgid "@code{display} (default @code{\":0\"})"
msgstr "@code{display}（默认值：@code{\":0\"}）"

msgid "@code{vt} (default @code{\"vt7\"})"
msgstr "@code{vt}（默认值：@code{\"vt7\"}）"

msgid "sddm has Qt6 enabled by default. If you want to still use a Qt5 theme, you need to set it to @code{sddm-qt5}."
msgstr "SDDM 默认启用 Qt6。如果您还想使用 Qt5 主题，需要将字段设置为 @code{sddm-qt5}."

msgid "This is a list of @dfn{module packages} loaded by the Xorg server---e.g., @code{xf86-video-vesa}, @code{xf86-input-libinput}, and so on."
msgstr "这是 Xorg 服务器加载的 @dfn{模块包} 列表——例如 @code{xf86-video-vesa}、@code{xf86-input-libinput} 等。"

msgid "log"
msgstr "log"

msgid "This is the type of a service to run the @uref{https://xfce.org/, Xfce} desktop environment.  Its value is an @code{xfce-desktop-configuration} object (see below)."
msgstr "这是运行@uref{https://xfce.org/, Xfce}桌面环境的服务类型。其值是一个@code{xfce-desktop-configuration}对象（见下文）。"

msgid "@code{xfce} (default: @code{xfce})"
msgstr "@code{xfce}（默认值：@code{xfce}）"

msgid "@code{mate} (default: @code{mate})"
msgstr "@code{mate}（默认值：@code{mate}）"

msgid "@code{enlightenment} (default: @code{enlightenment})"
msgstr "@code{enlightenment}（默认值：@code{enlightenment}）"

msgid ""
"(user-account\n"
"  (name \"alice\")\n"
"  (group \"users\")\n"
"  (supplementary-groups '(\"wheel\"   ; allow use of sudo, etc.\n"
"                          \"seat\"    ; seat management\n"
"                          \"audio\"   ; sound card\n"
"                          \"video\"   ; video devices such as webcams\n"
"                          \"cdrom\")) ; the good ol' CD-ROM\n"
"  (comment \"Bob's sister\"))\n"
msgstr ""
"(user-account\n"
"  (name \"XiaoHong\")\n"
"  (group \"users\")\n"
"  (supplementary-groups '(\"wheel\"   ; 允许使用 sudo 等\n"
"                          \"seat\"    ; seat 管理\n"
"                          \"audio\"   ; 声卡\n"
"                          \"video\"   ; 视频设备比如网络摄像头\n"
"                          \"cdrom\")) ; 老式 CD-ROM\n"
"  (comment \"小明的同学\"))\n"

msgid ""
"  capture_ports @{\n"
"    0 system:capture_1\n"
"    1 system:capture_2\n"
"  @}\n"
"@}\n"
"\n"
msgstr ""
"  capture_ports @{\n"
"    0 system:capture_1\n"
"    1 system:capture_2\n"
"  @}\n"
"@}\n"
"\n"

msgid ""
"pcm.!default @{\n"
"  type plug\n"
"  slave @{\n"
"    pcm \"rawjack\"\n"
"  @}\n"
"@}\n"
msgstr ""
"pcm.!default @{\n"
"  type plug\n"
"  slave @{\n"
"    pcm \"rawjack\"\n"
"  @}\n"
"@}\n"

msgid "locate important-notes.txt\n"
msgstr "locate important-notes.txt\n"

msgid ""
"sudo -u postgres -s /bin/sh\n"
"createuser --interactive\n"
"createdb $MY_USER_LOGIN      # Replace appropriately.\n"
msgstr ""
"sudo -u postgres -s /bin/sh\n"
"createuser --interactive\n"
"createdb $MY_USER_LOGIN      # 适当替换。\n"

msgid ""
"psql -U postgres\n"
"> create database postgistest;\n"
"> \\connect postgistest;\n"
"> create extension postgis;\n"
"> create extension postgis_topology;\n"
msgstr ""
"psql -U postgres\n"
"> create database postgistest;\n"
"> \\connect postgistest;\n"
"> create extension postgis;\n"
"> create extension postgis_topology;\n"

msgid ""
"(service dovecot-service-type\n"
"         (dovecot-configuration\n"
"           (mail-location \"maildir:~/.mail\")))\n"
msgstr ""
"(service dovecot-service-type\n"
"         (dovecot-configuration\n"
"           (mail-location \"maildir:~/.mail\")))\n"

msgid "(extensions (list dovecot-pigeonhole))\n"
msgstr "(extensions (list dovecot-pigeonhole))\n"

msgid "home directory"
msgstr "家目录"

msgid "prosodyctl --root cert import /etc/certs\n"
msgstr "prosodyctl --root cert import /etc/certs\n"

msgid ""
"# herd doc jami list-actions\n"
"(list-accounts\n"
" list-account-details\n"
" list-banned-contacts\n"
" list-contacts\n"
" list-moderators\n"
" add-moderator\n"
" ban-contact\n"
" enable-account\n"
" disable-account)\n"
msgstr ""
"# herd doc jami list-actions\n"
"(list-accounts\n"
" list-account-details\n"
" list-banned-contacts\n"
" list-contacts\n"
" list-moderators\n"
" add-moderator\n"
" ban-contact\n"
" enable-account\n"
" disable-account)\n"

msgid ""
"# herd add-moderator jami 1dbcb0f5f37324228235564b79f2b9737e9a008f \\\n"
"  f3345f2775ddfe07a4b0d95daea111d15fbc1199\n"
"\n"
msgstr ""
"# herd add-moderator jami 1dbcb0f5f37324228235564b79f2b9737e9a008f \\\n"
"  f3345f2775ddfe07a4b0d95daea111d15fbc1199\n"
"\n"

msgid ""
"# herd list-moderators jami\n"
"Moderators for account f3345f2775ddfe07a4b0d95daea111d15fbc1199:\n"
"  - 1dbcb0f5f37324228235564b79f2b9737e9a008f\n"
"\n"
msgstr ""
"# herd list-moderators jami\n"
"Moderators for account f3345f2775ddfe07a4b0d95daea111d15fbc1199:\n"
"  - 1dbcb0f5f37324228235564b79f2b9737e9a008f\n"
"\n"

msgid ""
"# herd ban-contact jami 1dbcb0f5f37324228235564b79f2b9737e9a008f\n"
"\n"
msgstr ""
"# herd ban-contact jami 1dbcb0f5f37324228235564b79f2b9737e9a008f\n"
"\n"

msgid ""
"# herd list-banned-contacts jami\n"
"Banned contacts for account f3345f2775ddfe07a4b0d95daea111d15fbc1199:\n"
"  - 1dbcb0f5f37324228235564b79f2b9737e9a008f\n"
"\n"
msgstr ""
"# herd list-banned-contacts jami\n"
"Banned contacts for account f3345f2775ddfe07a4b0d95daea111d15fbc1199:\n"
"  - 1dbcb0f5f37324228235564b79f2b9737e9a008f\n"
"\n"

msgid ""
"# herd disable-account jami f3345f2775ddfe07a4b0d95daea111d15fbc1199\n"
"\n"
msgstr ""
"# herd disable-account jami f3345f2775ddfe07a4b0d95daea111d15fbc1199\n"
"\n"

msgid ""
"# herd list-accounts jami\n"
"The following Jami accounts are available:\n"
"  - f3345f2775ddfe07a4b0d95daea111d15fbc1199 (dummy) [disabled]\n"
"\n"
msgstr ""
"# herd list-accounts jami\n"
"The following Jami accounts are available:\n"
"  - f3345f2775ddfe07a4b0d95daea111d15fbc1199 (dummy) [disabled]\n"
"\n"

msgid ""
"# herd list-account-details jami | \\\n"
"  recsel -p Account.username -e 'Account.rendezVous ~ \"true\"'\n"
"Account_username: f3345f2775ddfe07a4b0d95daea111d15fbc1199\n"
msgstr ""
"# herd list-account-details jami | \\\n"
"  recsel -p Account.username -e 'Account.rendezVous ~ \"true\"'\n"
"Account_username: f3345f2775ddfe07a4b0d95daea111d15fbc1199\n"

msgid ""
"$ guix repl\n"
"scheme@@(guix-user)> ,use (gnu services file-sharing)\n"
"scheme@@(guix-user)> (transmission-random-salt)\n"
"$1 = \"uKd1uMs9\"\n"
msgstr ""
"$ guix repl\n"
"scheme@@(guix-user)> ,use (gnu services file-sharing)\n"
"scheme@@(guix-user)> (transmission-random-salt)\n"
"$1 = \"uKd1uMs9\"\n"

msgid ""
"scheme@@(guix-user)> (transmission-password-hash \"transmission\"\n"
"(transmission-random-salt))\n"
"$2 = \"@{c8bbc6d1740cd8dc819a6e25563b67812c1c19c9VtFPfdsX\"\n"
msgstr ""
"scheme@@(guix-user)> (transmission-password-hash \"transmission\"\n"
"(transmission-random-salt))\n"
"$2 = \"@{c8bbc6d1740cd8dc819a6e25563b67812c1c19c9VtFPfdsX\"\n"

msgid "# herd reload transmission-daemon\n"
msgstr "# herd reload transmission-daemon\n"

msgid "@uref{https://codeberg.org/guix/mumi, Mumi} is a Web interface to the Debbugs bug tracker, by default for @uref{https://bugs.gnu.org, the GNU instance}.  Mumi is a Web server, but it also fetches and indexes mail retrieved from Debbugs."
msgstr "@uref{https://codeberg.org/guix/mumi, Mumi} 是一个 Web 界面，用于 Debbugs 缺陷跟踪器，默认情况下用于 @uref{https://bugs.gnu.org, GNU 实例}。Mumi 是一个 Web 服务器，但它还会获取和索引从 Debbugs 检索的邮件。"

msgid ""
"openssl genpkey -out key.der -outform DER -algorithm RSA \\\n"
"    -pkeyopt rsa_keygen_bits:4096\n"
"openssl req -x509 -key key.der -outform DER -days 3650 -out cert.der \\\n"
"    -subj \"/CN=example.com\"\n"
msgstr ""
"openssl genpkey -out key.der -outform DER -algorithm RSA \\\n"
"    -pkeyopt rsa_keygen_bits:4096\n"
"openssl req -x509 -key key.der -outform DER -days 3650 -out cert.der \\\n"
"    -subj \"/CN=example.com\"\n"

msgid "By using this service, you agree to the ACME Subscriber Agreement, which can be found there: @url{https://acme-v02.api.letsencrypt.org/directory}."
msgstr "使用此服务即表示您同意 ACME 订阅者协议，协议可以在此找到：@url{https://acme-v02.api.letsencrypt.org/directory}."

msgid "@code{challenge} (default: @code{#f})"
msgstr "@code{challenge}（默认值：@code{#f}）"

msgid "@code{authentication-hook} (default: @code{#f})"
msgstr "@code{authentication-hook}（默认值：@code{#f}）"

msgid "@code{cleanup-hook} (default: @code{#f})"
msgstr "@code{cleanup-hook}（默认值：@code{#f}）"

msgid "@code{zonefile-load} (default: @code{#f})"
msgstr "@code{zonefile-load}（默认值：@code{#f}）"

msgid "@code{journal-content} (default: @code{#f})"
msgstr "@code{journal-content}（默认值：@code{#f}）"

msgid "@code{max-journal-usage} (default: @code{#f})"
msgstr "@code{max-journal-usage}（默认值：@code{#f}）"

msgid "@code{max-journal-depth} (default: @code{#f})"
msgstr "@code{max-journal-depth}（默认值：@code{#f}）"

msgid "@code{max-zone-size} (default: @code{#f})"
msgstr "@code{max-zone-size}（默认值：@code{#f}）"

msgid "@code{dnssec-policy} (default: @code{#f})"
msgstr "@code{dnssec-policy}（默认值：@code{#f}）"

msgid "@code{includes} (default: @code{'()})"
msgstr "@code{includes}（默认值：@code{'()}）"

msgid "secrets, Knot service"
msgstr "秘密，Knot 服务。"

msgid ""
"keymgr -t mysecret > /etc/knot/secrets.conf\n"
"chmod 600 /etc/knot/secrets.conf\n"
msgstr ""
"keymgr -t mysecret > /etc/knot/secrets.conf\n"
"chmod 600 /etc/knot/secrets.conf\n"

msgid "herd reload dnsmasq\n"
msgstr "herd reload dnsmasq\n"

msgid "herd stats dnsmasq\n"
msgstr "herd stats dnsmasq\n"

msgid ""
"(service xvnc-service-type\n"
"         (xvnc-configuration (display-number 10)))\n"
msgstr ""
"(service xvnc-service-type\n"
"         (xvnc-configuration (display-number 10)))\n"

msgid "vncviewer remote-host:5905\n"
msgstr "vncviewer remote-host:5905\n"

msgid "Bitmask"
msgstr "Bitmask"

msgid ""
"[public]\n"
"browsable = yes\n"
"path = /public\n"
"read only = no\n"
"guest ok = yes\n"
"guest only = yes\\n\"))))\n"
msgstr ""
"[public]\n"
"browsable = yes\n"
"path = /public\n"
"read only = no\n"
"guest ok = yes\n"
"guest only = yes\\n\"))))\n"

msgid "Web Service Discovery Daemon"
msgstr "Web 服务发现守护进程"

msgid "herd register forgejo-runner @var{url} @var{token}\n"
msgstr "herd register forgejo-runner @var{url} @var{token}\n"

msgid ""
"herd enable forgejo-runner\n"
"herd start forgejo-runner\n"
msgstr ""
"herd enable forgejo-runner\n"
"herd start forgejo-runner\n"

msgid "Most new UPSes are an USB."
msgstr "大多数新的 UPS 是一个 USB。"

msgid "Set to the appropriate @file{/dev/tty**} device."
msgstr "设置为合适的@file{/dev/tty**}设备。"

msgid "Set to @code{@var{hostname}:@var{port}}."
msgstr "设置为@code{@var{hostname}:@var{port}}。"

msgid "The logging facility for the syslog."
msgstr "syslog 的日志功能。"

msgid "Handlers for events produced by apcupsd."
msgstr "apcupsd 生成的事件把柄。"

msgid "(err @var{fmt} @var{args...})"
msgstr "(err @var{fmt} @var{args...})"

msgid "(wall @var{fmt} @var{args...})"
msgstr "(wall @var{fmt} @var{args...})"

msgid "The handler for the killpower event."
msgstr "关闭电源事件的把柄。"

msgid "The handler for the onbattery event."
msgstr "电源开启事件的把柄。"

msgid "herd update mpd\n"
msgstr "herd update mpd\n"

msgid "Port for accepting secure TLS connections This can be a port number, or service name."
msgstr "用于接受安全 TLS 连接的端口。这可以是端口号或服务名称。"

msgid "Port for accepting insecure TCP connections This can be a port number, or service name."
msgstr "用于接受不安全 TCP 连接的端口。这可以是端口号或服务名称。"

msgid "UNIX domain socket group ownership.  This can be used to allow a trusted set of users access to management capabilities without becoming root."
msgstr "UNIX 域套接字组所有权。这可以用于允许一组受信任的用户在不成为 root 的情况下访问管理功能。"

msgid "UNIX socket permissions for the R/W socket.  Default allows only root.  If PolicyKit is enabled on the socket, the default will change to allow everyone (e.g., @code{\"0777\"})."
msgstr "读写套接字的 UNIX 套接字权限。默认仅允许 root。如果在套接字上启用了 PolicyKit，默认将更改为允许所有人（例如，@code{\"0777\"}）。"

msgid "Authentication scheme for UNIX read-only sockets.  By default socket permissions allow anyone to connect."
msgstr "UNIX 只读套接字的身份验证方案。默认情况下，套接字权限允许任何人连接。"

msgid "Authentication scheme for TCP sockets.  If you don't enable SASL, then all TCP traffic is cleartext.  Don't do this outside of a development/test scenario."
msgstr "TCP 套接字的身份验证方案。如果您不启用 SASL，则所有 TCP 流量都是明文。不要在开发/测试场景之外这样做。"

msgid "Host UUID.  UUID must not have all digits be the same."
msgstr "主机 UUID。UUID 不能全部是相同的数字。"

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

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

msgid "guix build -s armhf-linux inkscape\n"
msgstr "guix build -s armhf-linux inkscape\n"

msgid ""
"qemu-system-x86_64 \\\n"
"\t-chardev socket,path=/tmp/qga.sock,server=on,wait=off,id=qga0 \\\n"
"\t-device virtio-serial \\\n"
"\t-device virtserialport,chardev=qga0,name=org.qemu.guest_agent.0 \\\n"
"\t...\n"
msgstr ""
"qemu-system-x86_64 \\\n"
"\t-chardev socket,path=/tmp/qga.sock,server=on,wait=off,id=qga0 \\\n"
"\t-device virtio-serial \\\n"
"\t-device virtserialport,chardev=qga0,name=org.qemu.guest_agent.0 \\\n"
"\t...\n"

msgid ""
"$ guix shell socat -- socat unix-connect:/tmp/qga.sock stdio\n"
"@{\"execute\": \"guest-get-host-name\"@}\n"
"@{\"return\": @{\"host-name\": \"guix\"@}@}\n"
msgstr ""
"$ guix shell socat -- socat unix-connect:/tmp/qga.sock stdio\n"
"@{\"execute\": \"guest-get-host-name\"@}\n"
"@{\"return\": @{\"host-name\": \"guix\"@}@}\n"

msgid "herd start build-vm\n"
msgstr "herd start build-vm\n"

msgid "herd configuration build-vm\n"
msgstr "herd configuration build-vm\n"

msgid "image"
msgstr "image"

msgid "qemu-system-x86_64 -cpu help\n"
msgstr "qemu-system-x86_64 -cpu help\n"

msgid ""
"herd start hurd-vm\n"
"herd stop childhurd\n"
msgstr ""
"herd start hurd-vm\n"
"herd stop childhurd\n"

msgid "guix shell tigervnc-client -- vncviewer localhost:5900\n"
msgstr "guix shell tigervnc-client -- vncviewer localhost:5900\n"

msgid "guix build emacs-minimal -s i586-gnu\n"
msgstr "guix build emacs-minimal -s i586-gnu\n"

msgid ""
"@var{secrets-port}: @code{(+ 11004 (* 1000 @var{ID}))}\n"
"@var{ssh-port}: @code{(+ 10022 (* 1000 @var{ID}))}\n"
"@var{vnc-port}: @code{(+ 15900 (* 1000 @var{ID}))}\n"
msgstr ""
"@var{secrets-port}: @code{(+ 11004 (* 1000 @var{ID}))}\n"
"@var{ssh-port}: @code{(+ 10022 (* 1000 @var{ID}))}\n"
"@var{vnc-port}: @code{(+ 15900 (* 1000 @var{ID}))}\n"

msgid "guix build coreutils -s i586-gnu\n"
msgstr "guix build coreutils -s i586-gnu\n"

msgid ""
"/etc/childhurd/etc/guix/acl\n"
"/etc/childhurd/etc/guix/signing-key.pub\n"
"/etc/childhurd/etc/guix/signing-key.sec\n"
"/etc/childhurd/etc/ssh/authorized_keys.d/offloading\n"
"/etc/childhurd/etc/ssh/ssh_host_ed25519_key\n"
"/etc/childhurd/etc/ssh/ssh_host_ecdsa_key\n"
"/etc/childhurd/etc/ssh/ssh_host_ed25519_key.pub\n"
"/etc/childhurd/etc/ssh/ssh_host_ecdsa_key.pub\n"
msgstr ""
"/etc/childhurd/etc/guix/acl\n"
"/etc/childhurd/etc/guix/signing-key.pub\n"
"/etc/childhurd/etc/guix/signing-key.sec\n"
"/etc/childhurd/etc/ssh/authorized_keys.d/offloading\n"
"/etc/childhurd/etc/ssh/ssh_host_ed25519_key\n"
"/etc/childhurd/etc/ssh/ssh_host_ecdsa_key\n"
"/etc/childhurd/etc/ssh/ssh_host_ed25519_key.pub\n"
"/etc/childhurd/etc/ssh/ssh_host_ecdsa_key.pub\n"

msgid "configuration"
msgstr "configuration"

msgid "git clone git@@example.com:gitolite-admin\n"
msgstr "git clone git@@example.com:gitolite-admin\n"

msgid ""
"(use-modules (gnu packages databases)\n"
"             (gnu packages haskell-apps)\n"
"             (gnu packages version-control))\n"
"(make-gitolite (list redis git-annex))\n"
msgstr ""
"(use-modules (gnu packages databases)\n"
"             (gnu packages haskell-apps)\n"
"             (gnu packages version-control))\n"
"(make-gitolite (list redis git-annex))\n"

msgid "admin-pubkey"
msgstr "admin-pubkey"

msgid ""
"repo foo\n"
"    R = daemon\n"
msgstr ""
"repo foo\n"
"    R = daemon\n"

msgid ""
"repo foo\n"
"    R = daemon\n"
"    desc = A long description, optionally with <i>HTML</i>, shown on the index page\n"
"    config gitweb.name = The Foo Project\n"
"    config gitweb.synopsis = A short description, shown on the main page of the project\n"
msgstr ""
"repo foo\n"
"    R = daemon\n"
"    desc = A long description, optionally with <i>HTML</i>, shown on the index page\n"
"    config gitweb.name = The Foo Project\n"
"    config gitweb.synopsis = A short description, shown on the main page of the project\n"

msgid "rules"
msgstr "rules"

msgid ""
"(list\n"
" #:build\n"
" (list\n"
"  (build-from-guix-data-service\n"
"   (data-service-url \"https://data.guix.gnu.org\")\n"
"   (build-coordinator-url \"http://127.0.0.1:8746\")\n"
"   (branches '(\"master\"))\n"
"   (systems '(\"x86_64-linux\" \"i686-linux\"))\n"
"   (systems-and-targets\n"
"    (map (lambda (target)\n"
"           (cons \"x86_64-linux\" target))\n"
"         '(\"aarch64-linux-gnu\"\n"
"           \"i586-pc-gnu\")))))\n"
" #:web-server-args\n"
" '(#:event-source \"https://example.com\"\n"
"   #:controller-args\n"
"   (#:title \"example.com build farm\")))\n"
msgstr ""
"(list\n"
" #:build\n"
" (list\n"
"  (build-from-guix-data-service\n"
"   (data-service-url \"https://data.guix.gnu.org\")\n"
"   (build-coordinator-url \"http://127.0.0.1:8746\")\n"
"   (branches '(\"master\"))\n"
"   (systems '(\"x86_64-linux\" \"i686-linux\"))\n"
"   (systems-and-targets\n"
"    (map (lambda (target)\n"
"           (cons \"x86_64-linux\" target))\n"
"         '(\"aarch64-linux-gnu\"\n"
"           \"i586-pc-gnu\")))))\n"
" #:web-server-args\n"
" '(#:event-source \"https://example.com\"\n"
"   #:controller-args\n"
"   (#:title \"example.com build farm\")))\n"

msgid "authentication"
msgstr "authentication"

msgid "This service is also available for Guix Home, where it runs directly with your user privileges (@pxref{Miscellaneous Home Services, @code{home-dicod-service-type}})."
msgstr "此服务也可用于 Guix Home，在那里它直接以您的用户权限运行(@pxref{Miscellaneous Home Services, @code{home-dicod-service-type}})."

msgid "{Procedure} dicod-freedict-database dictionary-name"
msgstr "{过程} dicod-freedict-database dictionary-name"

msgid ""
"(operating-system\n"
"  ;; @dots{}\n"
"  (users (cons (user-account\n"
"                (name \"alice\")\n"
"                (comment \"Bob's sister\")\n"
"                (group \"users\")\n"
"\n"
msgstr ""
"(operating-system\n"
"  ;; @dots{}\n"
"  (users (cons (user-account\n"
"                (name \"Xiaohong\")\n"
"                (comment \"小明的同学\")\n"
"                (group \"users\")\n"
"\n"

msgid ""
"$ podman run -it --rm docker.io/alpine cat /etc/*release*\n"
"NAME=\"Alpine Linux\"\n"
"ID=alpine\n"
"VERSION_ID=3.20.2\n"
"PRETTY_NAME=\"Alpine Linux v3.20\"\n"
"HOME_URL=\"https://alpinelinux.org/\"\n"
"BUG_REPORT_URL=\"https://gitlab.alpinelinux.org/alpine/aports/-/issues\"\n"
msgstr ""
"$ podman run -it --rm docker.io/alpine cat /etc/*release*\n"
"NAME=\"Alpine Linux\"\n"
"ID=alpine\n"
"VERSION_ID=3.20.2\n"
"PRETTY_NAME=\"Alpine Linux v3.20\"\n"
"HOME_URL=\"https://alpinelinux.org/\"\n"
"BUG_REPORT_URL=\"https://gitlab.alpinelinux.org/alpine/aports/-/issues\"\n"

msgid ""
"# cat /etc/subgid\n"
"root:100000:65536\n"
"alice:165536:65536\n"
"# cat /etc/subuid\n"
"root:100000:700\n"
"bob:100700:65536\n"
"alice:166236:65536\n"
msgstr ""
"# cat /etc/subgid\n"
"root:100000:65536\n"
"alice:165536:65536\n"
"# cat /etc/subuid\n"
"root:100000:700\n"
"bob:100700:65536\n"
"alice:166236:65536\n"

msgid ""
"$ nix-channel --add https://nixos.org/channels/nixpkgs-unstable\n"
"$ nix-channel --update\n"
msgstr ""
"$ nix-channel --add https://nixos.org/channels/nixpkgs-unstable\n"
"$ nix-channel --update\n"

msgid ""
"$ sudo mkdir -p /nix/var/nix/profiles/per-user/$USER\n"
"$ sudo chown $USER:root /nix/var/nix/profiles/per-user/$USER\n"
msgstr ""
"$ sudo mkdir -p /nix/var/nix/profiles/per-user/$USER\n"
"$ sudo chown $USER:root /nix/var/nix/profiles/per-user/$USER\n"

msgid ""
"$ ln -s \"/nix/var/nix/profiles/per-user/$USER/profile\" ~/.nix-profile\n"
"$ source /run/current-system/profile/etc/profile.d/nix.sh\n"
msgstr ""
"$ ln -s \"/nix/var/nix/profiles/per-user/$USER/profile\" ~/.nix-profile\n"
"$ source /run/current-system/profile/etc/profile.d/nix.sh\n"

msgid "sudo herd trigger remote-ftp\n"
msgstr "sudo herd trigger remote-ftp\n"

msgid "This service is also available for Guix Home, where it runs directly with your user privileges (@pxref{Miscellaneous Home Services, @code{home-readymedia-service-type}})."
msgstr "此服务也可用于 Guix Home，在那里它直接以您的用户权限运行(@pxref{Miscellaneous Home Services, @code{home-readymedia-service-type}})."

msgid ""
"guix install nss-certs\n"
"export SSL_CERT_DIR=\"$HOME/.guix-profile/etc/ssl/certs\"\n"
"export SSL_CERT_FILE=\"$HOME/.guix-profile/etc/ssl/certs/ca-certificates.crt\"\n"
"export GIT_SSL_CAINFO=\"$SSL_CERT_FILE\"\n"
msgstr ""
"guix install nss-certs\n"
"export SSL_CERT_DIR=\"$HOME/.guix-profile/etc/ssl/certs\"\n"
"export SSL_CERT_FILE=\"$HOME/.guix-profile/etc/ssl/certs/ca-certificates.crt\"\n"
"export GIT_SSL_CAINFO=\"$SSL_CERT_FILE\"\n"

msgid ""
"guix install nss-certs\n"
"export CURL_CA_BUNDLE=\"$HOME/.guix-profile/etc/ssl/certs/ca-certificates.crt\"\n"
msgstr ""
"guix install nss-certs\n"
"export CURL_CA_BUNDLE=\"$HOME/.guix-profile/etc/ssl/certs/ca-certificates.crt\"\n"

msgid "For bootstrapping purposes, the Linux-Libre kernel is passed an @dfn{initial RAM disk}, or @dfn{initrd}.  An initrd contains a temporary root file system as well as an initialization script.  The latter is responsible for mounting the real root file system, and for loading any kernel modules that may be needed to achieve that."
msgstr "为实现引导初始化，Linux-Libre 内核需加载@dfn{初始化内存盘}（Initial RAM Disk，或称 @dfn{initrd}）。该内存盘包含临时根文件系统及初始化脚本，其核心职责包括挂载真实根文件系统，并加载必要的内核模块。"

msgid "The @code{initrd-modules} field of an @code{operating-system} declaration allows you to specify Linux-libre kernel modules that must be available in the initrd.  In particular, this is where you would list modules needed to actually drive the hard disk where your root partition is---although the default value of @code{initrd-modules} should cover most use cases.  For example, assuming you need the @code{megaraid_sas} module in addition to the default modules to be able to access your root file system, you would write:"
msgstr "在 @code{operating-system} 系统声明中，通过 @code{initrd-modules} 字段可指定 initrd 必须包含的 Linux-libre 内核模块。特别要注意：此处应列出驱动根分区所在硬盘所需模块——尽管 @code{initrd-modules} 的默认值已覆盖多数场景。例如，若除默认模块外还需 @code{megaraid_sas} 模块访问根文件系统，则声明如下："

msgid ""
"(operating-system\n"
"  ;; @dots{}\n"
"  (initrd-modules (cons \"megaraid_sas\" %base-initrd-modules)))\n"
msgstr ""
"(operating-system\n"
"  ;; @dots{}\n"
"  (initrd-modules (cons \"megaraid_sas\" %base-initrd-modules)))\n"

msgid "%base-initrd-modules"
msgstr "%base-initrd-modules"

msgid "This is the list of kernel modules included in the initrd by default."
msgstr "此乃是默认包含于 initrd 的内核模块列表。"

msgid "Furthermore, if you need lower-level customization, the @code{initrd} field of an @code{operating-system} declaration allows you to specify which initrd you would like to use.  The @code{(gnu system linux-initrd)} module provides three ways to build an initrd: the high-level @code{base-initrd} procedure and the low-level @code{raw-initrd} and @code{expression->initrd} procedures."
msgstr "若需更深层定制，可通过 @code{operating-system} 声明的 @code{initrd} 字段指定自定义 initrd。@code{(gnu system linux-initrd)} 模块提供三种 initrd 构建方式：高级过程 @code{base-initrd}；底层过程 @code{raw-initrd} 与 @code{expression->initrd}。"

msgid "The @code{base-initrd} procedure is intended to cover most common uses.  For example, if you want to add a bunch of kernel modules to be loaded at boot time, you can define the @code{initrd} field of the operating system declaration like this:"
msgstr "@code{base-initrd} 过程覆盖多数常见需求。例如，若需在启动时加载额外内核模块，可在系统声明中如下定义 @code{initrd} 字段："

msgid ""
"(initrd (lambda (file-systems . rest)\n"
"          ;; Create a standard initrd but set up networking\n"
"          ;; with the parameters QEMU expects by default.\n"
"          (apply base-initrd file-systems\n"
"                 #:qemu-networking? #t\n"
"                 rest)))\n"
msgstr ""
"(initrd (lambda (file-systems . rest)\n"
"          ;; 创建标准 initrd 但默认采用 QEMU 所需的网络参数配置\n"
"          (apply base-initrd file-systems\n"
"                 #:qemu-networking? #t\n"
"                 rest)))\n"

msgid "The @code{base-initrd} procedure also handles common use cases that involves using the system as a QEMU guest, or as a ``live'' system with volatile root file system."
msgstr "@code{base-initrd} 过程同时支持两种常见场景：作为 QEMU 访客系统运行；或作为根文件系统易失的“临时”系统。"

msgid "The @code{base-initrd} procedure is built from @code{raw-initrd} procedure.  Unlike @code{base-initrd}, @code{raw-initrd} doesn't do anything high-level, such as trying to guess which kernel modules and packages should be included to the initrd.  An example use of @code{raw-initrd} is when a user has a custom Linux kernel configuration and default kernel modules included by @code{base-initrd} are not available."
msgstr "@code{base-initrd} 过程基于 @code{raw-initrd} 构建。与前者不同，@code{raw-initrd} 不执行高级操作（如自动推断需包含的内核模块和软件包）。典型用例：当用户使用自定义 Linux 内核配置且 @code{base-initrd} 默认包含的内核模块不可用时。"

msgid "The initial RAM disk produced by @code{base-initrd} or @code{raw-initrd} honors several options passed on the Linux kernel command line (that is, arguments passed @i{via} the @code{linux} command of GRUB, or the @code{-append} option of QEMU), notably:"
msgstr "由 @code{base-initrd} 或 @code{raw-initrd} 生成的初始化内存盘支持通过 Linux 内核命令行传递的若干选项（即通过 GRUB 的 @code{linux} 命令或 QEMU 的 @code{-append} 选项传递的参数），特别是："

msgid "gnu.load=@var{boot}"
msgstr "gnu.load=@var{boot}"

msgid "Tell the initial RAM disk to load @var{boot}, a file containing a Scheme program, once it has mounted the root file system."
msgstr "指示初始化内存盘在挂载根文件系统后加载包含 Scheme 程序的文件 @var{boot}。"

msgid "Guix uses this option to yield control to a boot program that runs the service activation programs and then spawns the GNU@tie{}Shepherd, the initialization system."
msgstr "Guix 利用此选项将控制权移交至引导程序，该程序执行服务激活流程后启动初始化系统 GNU@tie{}Shepherd。"

msgid "root=@var{root}"
msgstr "root=@var{root}"

msgid "Mount @var{root} as the root file system.  @var{root} can be a device name like @code{/dev/sda1}, a file system label, or a file system UUID.  When unspecified, the device name from the root file system of the operating system declaration is used."
msgstr "将 @var{root} 挂载为根文件系统。@var{root} 可以是设备名（如 @code{/dev/sda1}）、文件系统标签或文件系统 UUID。若未指定，则使用操作系统声明中根文件系统的设备名。"

msgid "rootfstype=@var{type}"
msgstr "rootfstype=@var{type}"

msgid "rootflags=@var{options}"
msgstr "rootflags=@var{options}"

msgid ""
"echo /key-file.bin | cpio -oH newc >/key-file.cpio\n"
"chmod 0000 /key-file.cpio\n"
msgstr ""
"echo /key-file.bin | cpio -oH newc >/key-file.cpio\n"
"chmod 0000 /key-file.cpio\n"

msgid "\"(hd0,msdos1)/boot/vmlinuz\"\n"
msgstr "\"(hd0,msdos1)/boot/vmlinuz\"\n"

msgid "Invoking @command{guix system}"
msgstr "调用 @command{guix system}"

msgid "guix system @var{options}@dots{} @var{action} @var{file}\n"
msgstr "guix system @var{options}@dots{} @var{action} @var{file}\n"

msgid ""
"$ guix system search console\n"
"name: console-fonts\n"
"location: gnu/services/base.scm:806:2\n"
"extends: shepherd-root\n"
"description: Install the given fonts on the specified ttys (fonts are per\n"
"+ virtual console on GNU/Linux).  The value of this service is a list of\n"
"+ tty/font pairs.  The font can be the name of a font provided by the `kbd'\n"
"+ package or any valid argument to `setfont', as in this example:\n"
"+\n"
"+      '((\"tty1\" . \"LatGrkCyr-8x16\")\n"
"+        (\"tty2\" . (file-append\n"
"+                      font-tamzen\n"
"+                      \"/share/kbd/consolefonts/TamzenForPowerline10x20.psf\"))\n"
"+        (\"tty3\" . (file-append\n"
"+                      font-terminus\n"
"+                      \"/share/consolefonts/ter-132n\"))) ; for HDPI\n"
"relevance: 9\n"
"\n"
msgstr ""
"$ guix system search console\n"
"name: console-fonts\n"
"location: gnu/services/base.scm:806:2\n"
"extends: shepherd-root\n"
"description: 在指定的 tty 上安装给定的字体（字体是 GNU/Linux 每个虚拟控制台的字体）。 此服务的值是一个由\n"
"+ tty/font 对构成的列表。 字体可以是 `kbd' 软件包提供的字体名称，也可以是 `setfont' 的任何有效参数，如本例所示：\n"
"+ \n"
"+      `((\"tty1\" . \"LatGrkCyr-8x16\")\n"
"+        (\"tty2\" . ,(file-append\n"
"+                       font-tamzen\n"
"+                       \"/share/kbd/consolefonts/TamzenForPowerline10x20.psf\"))\n"
"+        (\"tty3\" . ,(file-append\n"
"+                       font-terminus\n"
"+                       \"/share/consolefonts/ter-132n\"))) ; for HDPI\n"
"relevance: 9\n"
"\n"

msgid "@dots{}\n"
msgstr "@dots{}\n"

msgid "guix system edit openssh\n"
msgstr "guix system edit openssh\n"

msgid ""
"guix time-machine \\\n"
"  -C /var/guix/profiles/system-@var{n}-link/channels.scm -- \\\n"
"  system reconfigure \\\n"
"  /var/guix/profiles/system-@var{n}-link/configuration.scm\n"
msgstr ""
"guix time-machine \\\n"
"  -C /var/guix/profiles/system-@var{n}-link/channels.scm -- \\\n"
"  system reconfigure \\\n"
"  /var/guix/profiles/system-@var{n}-link/configuration.scm\n"

msgid "guix system switch-generation 7\n"
msgstr "guix system switch-generation 7\n"

msgid "guix system switch-generation -- -1\n"
msgstr "guix system switch-generation -- -1\n"

msgid "guix system delete-generations\n"
msgstr "guix system delete-generations\n"

msgid "guix system delete-generations 2m\n"
msgstr "guix system delete-generations 2m\n"

msgid "guix system init my-os-config.scm /mnt\n"
msgstr "guix system init my-os-config.scm /mnt\n"

msgid "guix system installer --dry-run\n"
msgstr "guix system installer --dry-run\n"

msgid "$ /gnu/store/@dots{}-run-vm.sh -m 1024 -smp 2 -nic user,model=virtio-net-pci\n"
msgstr "$ /gnu/store/@dots{}-run-vm.sh -m 1024 -smp 2 -nic user,model=virtio-net-pci\n"

msgid "$ $(guix system vm my-config.scm) -m 1024 -smp 2 -nic user,model=virtio-net-pci\n"
msgstr "$ $(guix system vm my-config.scm) -m 1024 -smp 2 -nic user,model=virtio-net-pci\n"

msgid ""
"guix system vm my-config.scm \\\n"
"   --expose=$HOME --share=$HOME/tmp=/exchange\n"
msgstr ""
"guix system vm my-config.scm \\\n"
"   --expose=$HOME --share=$HOME/tmp=/exchange\n"

msgid ""
"image=$(guix system image --image-type=qcow2 \\\n"
"        gnu/system/examples/lightweight-desktop.tmpl)\n"
"cp $image /tmp/my-image.qcow2\n"
"chmod +w /tmp/my-image.qcow2\n"
"qemu-system-x86_64 -enable-kvm -hda /tmp/my-image.qcow2 -m 1000 \\\n"
"                   -bios $(guix build ovmf-x86-64)/share/firmware/ovmf_x64.bin\n"
msgstr ""
"image=$(guix system image --image-type=qcow2 \\\n"
"        gnu/system/examples/lightweight-desktop.tmpl)\n"
"cp $image /tmp/my-image.qcow2\n"
"chmod +w /tmp/my-image.qcow2\n"
"qemu-system-x86_64 -enable-kvm -hda /tmp/my-image.qcow2 -m 1000 \\\n"
"                   -bios $(guix build ovmf-x86-64)/share/firmware/ovmf_x64.bin\n"

msgid "# dd if=$(guix system image my-os.scm) of=/dev/sdc status=progress\n"
msgstr "# dd if=$(guix system image my-os.scm) of=/dev/sdc status=progress\n"

msgid ""
"image_id=\"$(docker load < guix-system-docker-image.tar.gz)\"\n"
"container_id=\"$(docker create $image_id)\"\n"
"docker start $container_id\n"
msgstr ""
"image_id=\"$(docker load < guix-system-docker-image.tar.gz)\"\n"
"container_id=\"$(docker create $image_id)\"\n"
"docker start $container_id\n"

msgid "docker exec -ti $container_id /run/current-system/profile/bin/bash --login\n"
msgstr "docker exec -ti $container_id /run/current-system/profile/bin/bash --login\n"

msgid ""
"guix system container my-config.scm \\\n"
"   --expose=$HOME --share=$HOME/tmp=/exchange\n"
msgstr ""
"guix system container my-config.scm \\\n"
"   --expose=$HOME --share=$HOME/tmp=/exchange\n"

msgid "guix system image -t qcow2 --save-provenance config.scm\n"
msgstr "guix system image -t qcow2 --save-provenance config.scm\n"

msgid "$ guix system list-generations 10d\n"
msgstr "$ guix system list-generations 10d\n"

msgid "$ guix system extension-graph @var{file} | xdot -\n"
msgstr "$ guix system extension-graph @var{file} | xdot -\n"

msgid "Invoking @command{guix deploy}"
msgstr "调用 @command{guix deploy}"

msgid "guix deploy"
msgstr "guix deploy"

msgid "guix deploy @var{file}\n"
msgstr "guix deploy @var{file}\n"

msgid "# guix archive --authorize < coordinator-public-key.txt\n"
msgstr "# guix archive --authorize < coordinator-public-key.txt\n"

msgid "guix deploy @var{file} -x -- uname -a\n"
msgstr "guix deploy @var{file} -x -- uname -a\n"

msgid "guix deploy @var{file} -x -- herd restart @var{service}\n"
msgstr "guix deploy @var{file} -x -- herd restart @var{service}\n"

msgid "guix deploy --roll-back @var{file}\n"
msgstr "guix deploy --roll-back @var{file}\n"

msgid "environment"
msgstr "environment"

msgid "system"
msgstr "system"

msgid "ssh-ed25519 AAAAC3Nz@dots{} root@@example.org\n"
msgstr "ssh-ed25519 AAAAC3Nz@dots{} root@@example.org\n"

msgid "ssh-key"
msgstr "ssh-key"

msgid "Running Guix in a Virtual Machine"
msgstr "在虚拟机中运行 Guix"

msgid ""
"$ qemu-system-x86_64 \\\n"
"   -nic user,model=virtio-net-pci \\\n"
"   -enable-kvm -m 2048 \\\n"
"   -device virtio-blk,drive=myhd \\\n"
"   -drive if=none,file=guix-system-vm-image-@value{VERSION}.x86_64-linux.qcow2,id=myhd\n"
msgstr ""
"$ qemu-system-x86_64 \\\n"
"   -nic user,model=virtio-net-pci \\\n"
"   -enable-kvm -m 2048 \\\n"
"   -device virtio-blk,drive=myhd \\\n"
"   -drive if=none,file=guix-system-vm-image-@value{VERSION}.x86_64-linux.qcow2,id=myhd\n"

msgid "$(guix system vm config.scm) -nic user,model=virtio-net-pci,hostfwd=tcp::10022-:22\n"
msgstr "$(guix system vm config.scm) -nic user,model=virtio-net-pci,hostfwd=tcp::10022-:22\n"

msgid "ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -p 10022 localhost\n"
msgstr "ssh -o UserKnownHostsFile=/dev/null -o StrictHostKeyChecking=no -p 10022 localhost\n"

msgid ""
"-device virtio-serial-pci,id=virtio-serial0,max_ports=16,bus=pci.0,addr=0x5\n"
"-chardev spicevmc,name=vdagent,id=vdagent\n"
"-device virtserialport,nr=1,bus=virtio-serial0.0,chardev=vdagent,\\\n"
"name=com.redhat.spice.0\n"
msgstr ""
"-device virtio-serial-pci,id=virtio-serial0,max_ports=16,bus=pci.0,addr=0x5\n"
"-chardev spicevmc,name=vdagent,id=vdagent\n"
"-device virtserialport,nr=1,bus=virtio-serial0.0,chardev=vdagent,\\\n"
"name=com.redhat.spice.0\n"

msgid "(@var{type} @var{variable} => @var{body})\n"
msgstr "(@var{type} @var{variable} => @var{body})\n"

msgid "(delete @var{type})\n"
msgstr "(delete @var{type})\n"

msgid ""
"(simple-service 'my-important-profile-file etc-profile-d-service-type\n"
"                (list (plain-file \"youppi.sh\" \"HOW_IMPORTANT=very\")))\n"
msgstr ""
"(simple-service 'my-important-profile-file etc-profile-d-service-type\n"
"                (list (plain-file \"youppi.sh\" \"HOW_IMPORTANT=very\")))\n"

msgid ""
"(use-package-modules gnome)     ;for the `vte' package\n"
"\n"
msgstr ""
"(use-package-modules gnome)     ;for the `vte' package\n"
"\n"

msgid ""
"(simple-service 'vte-integration etc-bashrc-d-service-type\n"
"                (list (file-append vte \"/etc/profile.d/vte.sh\")))\n"
msgstr ""
"(simple-service 'vte-integration etc-bashrc-d-service-type\n"
"                (list (file-append vte \"/etc/profile.d/vte.sh\")))\n"

msgid "(service vte-integration-service-type vte)\n"
msgstr "(service vte-integration-service-type vte)\n"

msgid "herd @var{action} @var{service} [@var{arguments}@dots{}]\n"
msgstr "herd @var{action} @var{service} [@var{arguments}@dots{}]\n"

msgid "herd doc @var{service-name}\n"
msgstr "herd doc @var{service-name}\n"

msgid ""
"(let ((config (plain-file \"syslogd.conf\" \"@dots{}\")))\n"
"  (shepherd-service\n"
"    (documentation \"Run the syslog daemon (syslogd).\")\n"
"    (provision '(syslogd))\n"
"    (requirement '(user-processes))\n"
"    (start #~(make-forkexec-constructor\n"
"               (list #$(file-append inetutils \"/libexec/syslogd\")\n"
"                     \"--rcfile\" #$config)\n"
"               #:pid-file \"/var/run/syslog.pid\"))\n"
"    (stop #~(make-kill-destructor))))\n"
msgstr ""
"(let ((config (plain-file \"syslogd.conf\" \"@dots{}\")))\n"
"  (shepherd-service\n"
"    (documentation \"Run the syslog daemon (syslogd).\")\n"
"    (provision '(syslogd))\n"
"    (requirement '(user-processes))\n"
"    (start #~(make-forkexec-constructor\n"
"               (list #$(file-append inetutils \"/libexec/syslogd\")\n"
"                     \"--rcfile\" #$config)\n"
"               #:pid-file \"/var/run/syslog.pid\"))\n"
"    (stop #~(make-kill-destructor))))\n"

msgid "herd doc @var{service} action @var{action}\n"
msgstr "herd doc @var{service} action @var{action}\n"

msgid ""
"# herd say-hello example\n"
"Hello, friend! arguments: ()\n"
"# herd say-hello example a b c\n"
"Hello, friend! arguments: (\"a\" \"b\" \"c\")\n"
msgstr ""
"# herd say-hello example\n"
"Hello, friend! arguments: ()\n"
"# herd say-hello example a b c\n"
"Hello, friend! arguments: (\"a\" \"b\" \"c\")\n"

msgid "cat $(herd configuration tor)\n"
msgstr "cat $(herd configuration tor)\n"

msgid ""
"herd spawn transient -E SSH_AUTH_SOCK=$SSH_AUTH_SOCK -- \\\n"
"  rsync -e ssh -vur . backup.example.org:\n"
msgstr ""
"herd spawn transient -E SSH_AUTH_SOCK=$SSH_AUTH_SOCK -- \\\n"
"  rsync -e ssh -vur . backup.example.org:\n"

msgid "herd schedule timer at 07:00 -- mpg123 Music/alarm.mp3\n"
msgstr "herd schedule timer at 07:00 -- mpg123 Music/alarm.mp3\n"

msgid ""
"(@var{field-name}\n"
" @var{type-decl}\n"
" @var{documentation}\n"
" @var{option*}\n"
" @dots{})\n"
msgstr ""
"(@var{field-name}\n"
" @var{type-decl}\n"
" @var{documentation}\n"
" @var{option*}\n"
" @dots{})\n"

msgid ""
"(define my-contacts\n"
"  (contacts-list-configuration\n"
"   (name \"Alice\")\n"
"   (email \"alice@@example.org\")\n"
"   (contacts\n"
"    (list (contact-configuration\n"
"           (name \"Bob\")\n"
"           (phone-number 1234)\n"
"           (email \"bob@@gnu.org\")\n"
"           (married? #f))\n"
"          (contact-configuration\n"
"           (name \"Charlie\")\n"
"           (phone-number 0000)\n"
"           (married? #t))))))\n"
msgstr ""
"(define my-contacts\n"
"  (contacts-list-configuration\n"
"   (name \"XiaoHong\")\n"
"   (email \"xiaohong@@example.org\")\n"
"   (contacts\n"
"    (list (contact-configuration\n"
"           (name \"XiaoMing\")\n"
"           (phone-number 1234)\n"
"           (email \"xiaoming@@gnu.org\")\n"
"           (married? #f))\n"
"          (contact-configuration\n"
"           (name \"LiHua\")\n"
"           (phone-number 0000)\n"
"           (married? #t))))))\n"

msgid ""
"[owner]\n"
"name = Alice\n"
"email = alice@@example.org\n"
"\n"
msgstr ""
"[owner]\n"
"name = Alice\n"
"email = alice@@example.org\n"
"\n"

msgid ""
"[Bob]\n"
"phone-number = 1234\n"
"email = bob@@gnu.org\n"
"is-married = false\n"
"\n"
msgstr ""
"[Bob]\n"
"phone-number = 1234\n"
"email = bob@@gnu.org\n"
"is-married = false\n"
"\n"

msgid ""
"[Charlie]\n"
"phone-number = 0\n"
"is-married = true\n"
msgstr ""
"[Charlie]\n"
"phone-number = 0\n"
"is-married = true\n"

msgid ""
"mount --rbind /proc /mnt/proc\n"
"mount --rbind /sys /mnt/sys\n"
"mount --rbind /dev /mnt/dev\n"
msgstr ""
"mount --rbind /proc /mnt/proc\n"
"mount --rbind /sys /mnt/sys\n"
"mount --rbind /dev /mnt/dev\n"

msgid "mount /dev/sda1 /mnt/boot/efi\n"
msgstr "mount /dev/sda1 /mnt/boot/efi\n"

msgid "chroot /mnt /bin/sh\n"
msgstr "chroot /mnt /bin/sh\n"

msgid ""
"source /var/guix/profiles/system/profile/etc/profile\n"
"source /home/@var{user}/.guix-profile/etc/profile\n"
msgstr ""
"source /var/guix/profiles/system/profile/etc/profile\n"
"source /home/@var{user}/.guix-profile/etc/profile\n"

msgid "source /home/@var{user}/.config/guix/current/etc/profile\n"
msgstr "source /home/@var{user}/.config/guix/current/etc/profile\n"

msgid "guix-daemon --build-users-group=guixbuild --disable-chroot &\n"
msgstr "guix-daemon --build-users-group=guixbuild --disable-chroot &\n"

msgid "guix system reconfigure your-config.scm\n"
msgstr "guix system reconfigure your-config.scm\n"

msgid "home configuration"
msgstr "家目录配置"

msgid "Guix supports declarative configuration of @dfn{home environments} by utilizing the configuration mechanism described in the previous chapter (@pxref{Defining Services}), but for user's dotfiles and packages.  It works both on Guix System and foreign distros and allows users to declare all the packages and services that should be installed and configured for the user.  Once a user has written a file containing a @code{home-environment} record, such a configuration can be @dfn{instantiated} by an unprivileged user with the @command{guix home} command (@pxref{Invoking guix home})."
msgstr "Guix 支持通过声明式方案配置@dfn{家环境}，其机制沿用了前文所述（@pxref{Defining Services}）的配置体系，但专用于用户的点文件及软件包管理。该方案兼容 Guix 系统与外部发行版，允许用户声明需安装配置的全部软件包及服务。用户编写包含 @code{home-environment} 记录的配置文件后，可通过非特权用户身份执行 @command{guix home} 命令实现配置的@dfn{实例化}（@pxref{Invoking guix home}）。"

msgid "The user's home environment usually consists of three basic parts: software, configuration, and state.  Software in mainstream distros are usually installed system-wide, but with GNU Guix most software packages can be installed on a per-user basis without needing root privileges, and are thus considered part of the user’s @dfn{home environment}.  Packages on their own are not very useful in many cases, because often they require some additional configuration, usually config files that reside in @env{XDG_CONFIG_HOME} (@file{~/.config} by default) or other directories.  Everything else can be considered state, like media files, application databases, and logs."
msgstr "家环境通常包含三个基础部分：软件、配置与状态（State）。主流发行版中软件通常需系统级安装，而 GNU Guix 支持多数软件包@dfn{按用户独立安装}（无需根用户权限），此类软件即构成用户的家环境。孤立软件包往往实用性有限，因其常需额外配置——通常体现为存放于 @env{XDG_CONFIG_HOME}（默认为 @file{~/.config}）或其他目录的配置文件。其余如媒体文件、应用数据库及日志等则归类为状态数据（State）。"

msgid "Using Guix for managing home environments provides a number of advantages:"
msgstr "采用 Guix 管理家环境的优势如下："

msgid "All software can be configured in one language (Guile Scheme),"
msgstr "所有软件均可通过单一语言（Guile Scheme）配置，"

msgid "this gives users the ability to share values between configurations of different programs."
msgstr "支持跨程序配置共享数据。"

msgid "A well-defined home environment is self-contained and can be"
msgstr "定义完善的家环境具备自包含性，"

msgid "created in a declarative and reproducible way---there is no need to grab external binaries or manually edit some configuration file."
msgstr "可通过声明式方案实现完全可复现——无需获取外部二进制文件或手动编辑配置文件。"

msgid "After every @command{guix home reconfigure} invocation, a new home"
msgstr "每次执行 @command{guix home reconfigure} 命令后，"

msgid "environment generation will be created.  This means that users can rollback to a previous home environment generation so they don’t have to worry about breaking their configuration."
msgstr "系统将创建新的家环境代，用户可随时回滚至历史代，彻底规避配置损坏风险。"

msgid "It is possible to manage stateful data with Guix Home, this"
msgstr "Guix Home 支持管理状态数据，"

msgid "includes the ability to automatically clone Git repositories on the initial setup of the machine, and periodically running commands like @command{rsync} to sync data with another host.  This functionality is still in an experimental stage, though."
msgstr "包括设备初始设置时自动克隆 Git 仓库，以及周期性执行 @command{rsync} 等命令实现跨主机同步。此功能目前仍属实验性阶段。"

msgid "The home environment is configured by providing a @code{home-environment} declaration in a file that can be passed to the @command{guix home} command (@pxref{Invoking guix home}).  The easiest way to get started is by generating an initial configuration with @command{guix home import}:"
msgstr "家环境通过在文件中定义 @code{home-environment} 声明实现，该文件可传递给 @command{guix home} 命令（@pxref{调用 guix home}）。最简入门方式是执行 @command{guix home import} 生成初始配置模板。"

msgid "guix home import ~/src/guix-config\n"
msgstr "guix home import ~/src/guix-config\n"

msgid "The @command{guix home import} command reads some of the ``dot files'' such as @file{~/.bashrc} found in your home directory and copies them to the given directory, @file{~/src/guix-config} in this case; it also reads the contents of your profile, @file{~/.guix-profile}, and, based on that, it populates @file{~/src/guix-config/home-configuration.scm} with a Home configuration that resembles your current configuration."
msgstr "@command{guix home import} 命令会读取家目录中的点文件（如 @file{~/.bashrc}），将其复制至指定目录（本例为 @file{~/src/guix-config}）；同时解析您的软件集 @file{~/.guix-profile} 内容，据此生成与当前配置相符的 @file{~/src/guix-config/home-configuration.scm} 家目录配置文件。"

msgid "A simple setup can include Bash and a custom text configuration, like in the example below.  Don't be afraid to declare home environment parts, which overlaps with your current dot files: before installing any configuration files, Guix Home will back up existing config files to a separate place in the home directory."
msgstr "基础配置可包含 Bash 及自定义文本配置，如下例所示。无需顾虑家环境配置与现有点文件的重叠：Guix Home 在安装配置文件前，会自动将现有配置备份至家目录独立存储区。"

msgid "It is highly recommended that you manage your shell or shells with Guix Home, because it will make sure that all the necessary scripts are sourced by the shell configuration file.  Otherwise you will need to do it manually. (@pxref{Configuring the Shell})."
msgstr "强烈建议通过 Guix Home 管理您的 shell 环境，因其可确保 shell 配置文件自动加载所有必要脚本，否则需手动配置（@pxref{Configuring the Shell}）。"

msgid "home-environment"
msgstr "home-environment"

msgid "%base-home-services"
msgstr "%base-home-services"

msgid "he-config-bare-bones.scm"
msgstr "he-config-bare-bones.scm"

msgid "The @code{packages} field should be self-explanatory, it will install the list of packages into the user's profile.  The most important field is @code{services}, it contains a list of @dfn{home services}, which are the basic building blocks of a home environment."
msgstr "@code{packages} 字段的作用不言而喻，其将在用户软件集中安装指定软件包列表。核心字段当属 @code{services}，它包含构成家环境基础单元的@dfn{家服务}（home service）列表。"

msgid "There is no daemon (at least not necessarily) related to a home service, a home service is just an element that is used to declare part of home environment and extend other parts of it.  The extension mechanism discussed in the previous chapter (@pxref{Defining Services}) should not be confused with Shepherd services (@pxref{Shepherd Services}).  Using this extension mechanism and some Scheme code that glues things together gives the user the freedom to declare their own, very custom, home environments."
msgstr "家服务（社区习惯称 home 服务）无需关联守护进程（至少非必需），其本质是用于声明并扩展家环境组件的元素。前文所述扩展机制（@pxref{Defining Services}）切勿与 Shepherd 服务（@pxref{Shepherd Services}）混淆。通过该扩展机制及协同处理的 Scheme 代码，用户可自由声明高度定制化的家环境。"

msgid "container, for @command{guix home}"
msgstr "@command{guix home} 的容器"

msgid "Once the configuration looks good, you can first test it in a throw-away ``container'':"
msgstr "当配置完善后，可先在临时“容器”中测试："

msgid "guix home container config.scm\n"
msgstr "guix home container config.scm\n"

msgid "The command above spawns a shell where your home environment is running.  The shell runs in a container, meaning it's isolated from the rest of the system, so it's a good way to try out your configuration---you can see if configuration bits are missing or misbehaving, if daemons get started, and so on.  Once you exit that shell, you're back to the prompt of your original shell ``in the real world''."
msgstr "上述命令将在隔离容器中启动包含您家环境的 Shell。容器化环境确保与主系统完全隔离，是测试配置的理想方式——可验证配置完整性、检测守护进程启动状态等。退出该 Shell 后即返回“现实世界”的原始终端环境。"

msgid "Once you have a configuration file that suits your needs, you can reconfigure your home by running:"
msgstr "当配置文件满足需求后，执行以下命令完成家目录的重新配置："

msgid "guix home reconfigure config.scm\n"
msgstr "guix home reconfigure config.scm\n"

msgid "This ``builds'' your home environment and creates @file{~/.guix-home} pointing to it.  Voilà!"
msgstr "此操作将构建您的家环境，并创建指向该环境的 @file{~/.guix-home}。大功告成！"

msgid "Make sure the operating system has elogind, systemd, or a similar mechanism to create the XDG run-time directory and has the @env{XDG_RUNTIME_DIR} variable set.  Failing that, the @file{on-first-login} script will not execute anything, and processes like user Shepherd and its descendants will not start."
msgstr "请确保操作系统具备 elogind、systemd 或类似机制以创建 XDG 运行时目录，且已设置 @env{XDG_RUNTIME_DIR} 环境变量。若未满足此条件，@file{on-first-login} 脚本将不会执行任何操作，用户 Shepherd 守护进程及其子进程亦无法启动。"

msgid "If you're using Guix System, you can embed your home configuration in your system configuration such that @command{guix system reconfigure} will deploy both the system @emph{and} your home at once! @xref{guix-home-service-type, @code{guix-home-service-type}}, for how to do that."
msgstr "若使用 Guix 系统，您可将家目录配置嵌入系统配置中，使 @command{guix system reconfigure} 命令同步部署系统@emph{与}家环境！具体方法参见 @xref{guix-home-service-type, @code{guix-home-service-type}}。"

msgid "This section is safe to skip if your shell or shells are managed by Guix Home.  Otherwise, read it carefully."
msgstr "若您已通过 Guix Home 管理 shell，本节内容可跳过。否则请仔细阅读。"

msgid "There are a few scripts that must be evaluated by a login shell to activate the home environment.  The shell startup files only read by login shells often have @code{profile} suffix.  For more information about login shells see @ref{Invoking Bash,,, bash, The GNU Bash Reference Manual} and see @ref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}."
msgstr "需由登录 Shell 执行若干脚本以激活家环境。登录 Shell 专属的启动文件通常带有 @code{profile} 后缀。关于登录 Shell 的详细说明参见 @ref{Invoking Bash,,, bash, The GNU Bash Reference Manual} 及 @ref{Bash Startup Files,,, bash, The GNU Bash Reference Manual}。"

msgid "The first script that needs to be sourced is @file{setup-environment}, which sets all the necessary environment variables (including variables declared by the user) and the second one is @file{on-first-login}, which starts Shepherd for the current user and performs actions declared by other home services that extends @code{home-run-on-first-login-service-type}."
msgstr "需首先加载的脚本是 @file{setup-environment}，用于设置所有必要的环境变量（含用户声明的变量）；其次是 @file{on-first-login}，其功能包括启动当前用户的 Shepherd 守护进程，并执行其他通过 @code{home-run-on-first-login-service-type} 扩展的家目录（home）服务声明的操作。"

msgid "Guix Home will always create @file{~/.profile}, which contains the following lines:"
msgstr "Guix Home 始终会创建包含以下内容的 @file{~/.profile} 文件："

msgid ""
"HOME_ENVIRONMENT=$HOME/.guix-home\n"
". $HOME_ENVIRONMENT/setup-environment\n"
"$HOME_ENVIRONMENT/on-first-login\n"
msgstr ""
"HOME_ENVIRONMENT=$HOME/.guix-home\n"
". $HOME_ENVIRONMENT/setup-environment\n"
"$HOME_ENVIRONMENT/on-first-login\n"

msgid "This makes POSIX compliant login shells activate the home environment.  However, in most cases this file won't be read by most modern shells, because they are run in non POSIX mode by default and have their own @file{*profile} startup files.  For example Bash will prefer @file{~/.bash_profile} in case it exists and only if it doesn't will it fallback to @file{~/.profile}.  Zsh (if no additional options are specified) will ignore @file{~/.profile}, even if @file{~/.zprofile} doesn't exist."
msgstr "此机制确保符合 POSIX 标准的登录 Shell 能激活家环境。但多数现代 Shell 默认运行于非 POSIX 模式，且拥有专属的 @file{*profile} 启动文件。如 Bash 优先读取 @file{~/.bash_profile}，仅当该文件不存在时才回退至 @file{~/.profile}；Zsh 则完全忽略 @file{~/.profile}（唉……），即便 @file{~/.zprofile} 缺失。"

msgid "To make your shell respect @file{~/.profile}, add @code{. ~/.profile} or @code{source ~/.profile} to the startup file for the login shell.  In case of Bash, it is @file{~/.bash_profile}, and in case of Zsh, it is @file{~/.zprofile}."
msgstr "要使 Shell 加载@footnote{原文为 “respect”，意为“尊重”。这样的写法使 Shell 人格化，而译文没有体现出这一点。} @file{~/.profile}，请在登录 Shell 的启动文件中添加 @code{. ~/.profile} 或 @code{source ~/.profile}。Bash 对应 @file{~/.bash_profile}，Zsh 对应 @file{~/.zprofile}。"

msgid "This step is only required if your shell is @emph{not} managed by Guix Home.  Otherwise, everything will be done automatically."
msgstr "此步骤仅当您的 shell @emph{未被} Guix Home 管理时需执行。若已管理，所有操作将自动完成。"

msgid "home services"
msgstr "家服务"

msgid "A @dfn{home service} is not necessarily something that has a daemon and is managed by Shepherd (@pxref{Jump Start,,, shepherd, The GNU Shepherd Manual}), in most cases it doesn't.  It's a simple building block of the home environment, often declaring a set of packages to be installed in the home environment profile, a set of config files to be symlinked into @env{XDG_CONFIG_HOME} (@file{~/.config} by default), and environment variables to be set by a login shell."
msgstr "@dfn{家服务}未必关联守护进程或由Shepherd管理（@pxref{Jump Start,,, shepherd, The GNU Shepherd Manual}），多数情况下其本质是家环境的基础组件。通常功能包括：声明需安装至家目录软件集的软件包组@footnote{原文为 “set” 而非 “group”。}、需符号链接至 @env{XDG_CONFIG_HOME}（默认 @file{~/.config}）的配置文件组，以及需由登录 Shell 设置的环境变量组。"

msgid "There is a service extension mechanism (@pxref{Service Composition})  which allows home services to extend other home services and utilize capabilities they provide; for example: declare mcron jobs (@pxref{Top,,, mcron, GNU@tie{}Mcron}) by extending @ref{Mcron Home Service}; declare daemons by extending @ref{Shepherd Home Service}; add commands, which will be invoked on by the Bash by extending @ref{Shells Home Services, @code{home-bash-service-type}}."
msgstr "存在服务扩展机制（@pxref{Service Composition}），允许家服务扩展其他服务并利用其提供的能力；例如：通过扩展 @ref{Mcron Home Service} 声明 mcron 任务（@pxref{Top,,, mcron, GNU@tie{}Mcron}）；通过扩展 @ref{Shepherd Home Service}声明守护进程；通过扩展 @ref{Shells Home Services, @code{home-bash-service-type}} 添加将由 Bash 执行的命令。"

msgid ""
"export LESSHISTFILE=\"$XDG_CACHE_HOME/.lesshst\"\n"
"export SHELL=\"/gnu/store/2hsg15n644f0glrcbkb1kqknmmqdar03-zsh-5.8/bin/zsh\"\n"
"export _JAVA_AWT_WM_NONREPARENTING\n"
"export LITERAL_VALUE='$@{abc@}'\n"
msgstr ""
"export LESSHISTFILE=\"$XDG_CACHE_HOME/.lesshst\"\n"
"export SHELL=\"/gnu/store/2hsg15n644f0glrcbkb1kqknmmqdar03-zsh-5.8/bin/zsh\"\n"
"export _JAVA_AWT_WM_NONREPARENTING\n"
"export LITERAL_VALUE='$@{abc@}'\n"

msgid ""
"~$ tree -a ./dotfiles/\n"
"dotfiles/\n"
"├── .gitconfig\n"
"├── .gnupg\n"
"│   ├── gpg-agent.conf\n"
"│   └── gpg.conf\n"
"├── .guile\n"
"├── .config\n"
"│   ├── guix\n"
"│   │   └── channels.scm\n"
"│   └── nixpkgs\n"
"│       └── config.nix\n"
"├── .nix-channels\n"
"├── .tmux.conf\n"
"└── .vimrc\n"
msgstr ""
"~$ tree -a ./dotfiles/\n"
"dotfiles/\n"
"├── .gitconfig\n"
"├── .gnupg\n"
"│   ├── gpg-agent.conf\n"
"│   └── gpg.conf\n"
"├── .guile\n"
"├── .config\n"
"│   ├── guix\n"
"│   │   └── channels.scm\n"
"│   └── nixpkgs\n"
"│       └── config.nix\n"
"├── .nix-channels\n"
"├── .tmux.conf\n"
"└── .vimrc\n"

msgid ""
"~$ tree -a ./dotfiles/\n"
"dotfiles/\n"
"├── git\n"
"│   └── .gitconfig\n"
"├── gpg\n"
"│   └── .gnupg\n"
"│       ├── gpg-agent.conf\n"
"│       └── gpg.conf\n"
"├── guile\n"
"│   └── .guile\n"
"├── guix\n"
"│   └── .config\n"
"│       └── guix\n"
"│           └── channels.scm\n"
"├── nix\n"
"│   ├── .config\n"
"│   │   └── nixpkgs\n"
"│   │       └── config.nix\n"
"│   └── .nix-channels\n"
"├── tmux\n"
"│   └── .tmux.conf\n"
"└── vim\n"
"    └── .vimrc\n"
"\n"
msgstr ""
"~$ tree -a ./dotfiles/\n"
"dotfiles/\n"
"├── git\n"
"│   └── .gitconfig\n"
"├── gpg\n"
"│   └── .gnupg\n"
"│       ├── gpg-agent.conf\n"
"│       └── gpg.conf\n"
"├── guile\n"
"│   └── .guile\n"
"├── guix\n"
"│   └── .config\n"
"│       └── guix\n"
"│           └── channels.scm\n"
"├── nix\n"
"│   ├── .config\n"
"│   │   └── nixpkgs\n"
"│   │       └── config.nix\n"
"│   └── .nix-channels\n"
"├── tmux\n"
"│   └── .tmux.conf\n"
"└── vim\n"
"    └── .vimrc\n"
"\n"

msgid ""
".\n"
"├── .config\n"
"│   ├── guix\n"
"│   │   └── channels.scm\n"
"│   └── nixpkgs\n"
"│       └── config.nix\n"
"├── .gitconfig\n"
"├── .gnupg\n"
"│   ├── gpg-agent.conf\n"
"│   └── gpg.conf\n"
"├── .guile\n"
"├── .nix-channels\n"
"├── .tmux.conf\n"
"└── .vimrc\n"
msgstr ""
".\n"
"├── .config\n"
"│   ├── guix\n"
"│   │   └── channels.scm\n"
"│   └── nixpkgs\n"
"│       └── config.nix\n"
"├── .gitconfig\n"
"├── .gnupg\n"
"│   ├── gpg-agent.conf\n"
"│   └── gpg.conf\n"
"├── .guile\n"
"├── .nix-channels\n"
"├── .tmux.conf\n"
"└── .vimrc\n"

msgid "alias ls=\"ls -alF\"\n"
msgstr "alias ls=\"ls -alF\"\n"

msgid "Control-l: clear-screen\n"
msgstr "Control-l: clear-screen\n"

msgid ""
"set bell-style visible\n"
"set colored-completion-prefix on\n"
msgstr ""
"set bell-style visible\n"
"set colored-completion-prefix on\n"

msgid ""
"$if mode=vi\n"
"set show-mode-in-prompt on\n"
"$else\n"
"Control-l: clear-screen\n"
"$endif\n"
msgstr ""
"$if mode=vi\n"
"set show-mode-in-prompt on\n"
"$else\n"
"Control-l: clear-screen\n"
"$endif\n"

msgid "cron, per-user"
msgstr "cron，对单个用户而言"

msgid "mcron, per-user"
msgstr "mcron，对单个用户而言"

msgid "The @code{(gnu home services mcron)} module provides an interface to GNU@tie{}mcron, a daemon to run jobs at scheduled times (@pxref{Top,,, mcron, GNU@tie{}mcron}).  The information about system's mcron is applicable here (@pxref{mcron-service, mcron reference}), the only difference for home services is that they have to be declared in a @code{home-environment} record instead of an @code{operating-system} record."
msgstr "@code{(gnu home services mcron)} 模块提供了与 GNU@tie{}mcron 的接口，这是一个在预定时间运行作业的守护进程 (@pxref{Top,,, mcron, GNU@tie{}mcron})。有关系统 mcron 的信息在这里适用 (@pxref{mcron-service, mcron 参考})，家庭服务的唯一区别是它们必须在 @code{home-environment} 记录中声明，而不是在 @code{operating-system} 记录中。"

msgid "timers, per-user"
msgstr "定时器，对单个用户而言"

msgid "herd start x11-display :3\n"
msgstr "herd start x11-display :3\n"

msgid ""
"(service home-unclutter-service-type\n"
"         (home-unclutter-configuration\n"
"          (idle-timeout 2)))\n"
msgstr ""
"(service home-unclutter-service-type\n"
"         (home-unclutter-configuration\n"
"          (idle-timeout 2)))\n"

msgid "herd start pulseaudio-rtp-sink\n"
msgstr "herd start pulseaudio-rtp-sink\n"

msgid "herd start pulseaudio-rtp-sink 192.168.1.42\n"
msgstr "herd start pulseaudio-rtp-sink 192.168.1.42\n"

msgid "(service home-pulseaudio-rtp-source-service-type)\n"
msgstr "(service home-pulseaudio-rtp-source-service-type)\n"

msgid "herd start pulseaudio-rtp-source\n"
msgstr "herd start pulseaudio-rtp-source\n"

msgid "pw-jack mpv -ao=jack sound-file.wav\n"
msgstr "pw-jack mpv -ao=jack sound-file.wav\n"

msgid "(service home-znc-service-type)\n"
msgstr "(service home-znc-service-type)\n"

msgid ""
"(service home-kodi-service-type\n"
"  (home-kodi-configuration\n"
"   (extra-options '(\"--settings=\"<settings-file>\"))))\n"
msgstr ""
"(service home-kodi-service-type\n"
"  (home-kodi-configuration\n"
"   (extra-options '(\"--settings=\"<settings-file>\"))))\n"

msgid ""
"(sway-mode\n"
" (mode-name \"resize\")\n"
" (keybindings\n"
"  '(($left  . \"resize shrink width 10px\")\n"
"    ($right . \"resize grow width 10px\")\n"
"    ($down  . \"resize grow height 10px\")\n"
"    ($up    . \"resize shrink height 10px\")\n"
"    (Left   . \"resize shrink width 10px\")\n"
"    (Right  . \"resize grow width 10px\")\n"
"    (Down   . \"resize grow height 10px\")\n"
"    (Up     . \"resize shrink height 10px\")\n"
"    (Return . \"mode \\\"default\\\"\")\n"
"    (Escape . \"mode \\\"default\\\"\"))))\n"
msgstr ""
"(sway-mode\n"
" (mode-name \"resize\")\n"
" (keybindings\n"
"  '(($left  . \"resize shrink width 10px\")\n"
"    ($right . \"resize grow width 10px\")\n"
"    ($down  . \"resize grow height 10px\")\n"
"    ($up    . \"resize shrink height 10px\")\n"
"    (Left   . \"resize shrink width 10px\")\n"
"    (Right  . \"resize grow width 10px\")\n"
"    (Down   . \"resize grow height 10px\")\n"
"    (Up     . \"resize shrink height 10px\")\n"
"    (Return . \"mode \\\"default\\\"\")\n"
"    (Escape . \"mode \\\"default\\\"\"))))\n"

msgid "Invoking @command{guix home}"
msgstr "调用 @command{guix home}"

msgid "guix home"
msgstr "guix home"

msgid "guix home @var{options}@dots{} @var{action} @var{file}\n"
msgstr "guix home @var{options}@dots{} @var{action} @var{file}\n"

msgid "guix home container config.scm -- herd status\n"
msgstr "guix home container config.scm -- herd status\n"

msgid "guix home edit home-mcron\n"
msgstr "guix home edit home-mcron\n"

msgid "guix home describe\n"
msgstr "guix home describe\n"

msgid ""
"guix time-machine \\\n"
"  -C /var/guix/profiles/per-user/@var{USER}/guix-home-@var{n}-link/channels.scm -- \\\n"
"  home reconfigure \\\n"
"  /var/guix/profiles/per-user/@var{USER}/guix-home-@var{n}-link/configuration.scm\n"
"\n"
msgstr ""
"guix time-machine \\\n"
"  -C /var/guix/profiles/per-user/@var{USER}/guix-home-@var{n}-link/channels.scm -- \\\n"
"  home reconfigure \\\n"
"  /var/guix/profiles/per-user/@var{USER}/guix-home-@var{n}-link/configuration.scm\n"
"\n"

msgid "guix home switch-generation 7\n"
msgstr "guix home switch-generation 7\n"

msgid "guix home switch-generation -- -1\n"
msgstr "guix home switch-generation -- -1\n"

msgid "guix home delete-generations\n"
msgstr "guix home delete-generations\n"

msgid "guix home delete-generations 2m\n"
msgstr "guix home delete-generations 2m\n"

msgid "guix home describe --list-installed=emacs\n"
msgstr "guix home describe --list-installed=emacs\n"

msgid "guix home list-generations 10d\n"
msgstr "guix home list-generations 10d\n"

msgid ""
"$ guix home import ~/guix-config\n"
"guix home: '/home/alice/guix-config' populated with all the Home configuration files\n"
msgstr ""
"$ guix home import ~/guix-config\n"
"guix home: '/home/alice/guix-config' 填充了所有家配置文件\n"

msgid "guix home extension-graph @var{file} | xdot -\n"
msgstr "guix home extension-graph @var{file} | xdot -\n"

msgid ""
"$ info -k TLS\n"
"\"(emacs)Network Security\" -- STARTTLS\n"
"\"(emacs)Network Security\" -- TLS\n"
"\"(gnutls)Core TLS API\" -- gnutls_certificate_set_verify_flags\n"
"\"(gnutls)Core TLS API\" -- gnutls_certificate_set_verify_function\n"
"@dots{}\n"
msgstr ""
"$ info -k TLS\n"
"\"(emacs)Network Security\" -- STARTTLS\n"
"\"(emacs)Network Security\" -- TLS\n"
"\"(gnutls)Core TLS API\" -- gnutls_certificate_set_verify_flags\n"
"\"(gnutls)Core TLS API\" -- gnutls_certificate_set_verify_function\n"
"@dots{}\n"

msgid ""
"$ man -k TLS\n"
"SSL (7)              - OpenSSL SSL/TLS library\n"
"certtool (1)         - GnuTLS certificate tool\n"
"@dots {}\n"
msgstr ""
"$ man -k TLS\n"
"SSL (7)              - OpenSSL SSL/TLS library\n"
"certtool (1)         - GnuTLS certificate tool\n"
"@dots {}\n"

msgid "$ info \"(gnutls)Core TLS API\"\n"
msgstr "$ info \"(gnutls)Core TLS API\"\n"

msgid "$ man certtool\n"
msgstr "$ man certtool\n"

msgid "@code{platform} Reference"
msgstr "@code{platform} 参考"

msgid "@code{partition} Reference"
msgstr "@code{partition} 参考手册"

msgid "guix system image my-image.scm\n"
msgstr "guix system image my-image.scm\n"

msgid "Same as @code{efi-disk-image} but with a 32 bits EFI partition."
msgstr "与 @code{efi-disk-image} 相同，但是有一个 32 位的 EFI 分区。"

msgid "An ISO-9660 image composed of a single bootable partition.  This image can also be used on most @code{x86_64} and @code{i686} machines."
msgstr "ISO-9660 镜像由一个可引导分区组成。这种镜像可以在大多数 @code{x86_64} 和 @code{i686} 机器上使用。"

msgid "A Docker image that can be used to spawn a Docker container."
msgstr "Docker 镜像可以用来孵化 Docker 容器。"

msgid "Using the @code{efi-disk-image} we can simplify our previous @code{image} declaration this way:"
msgstr "使用 @code{efi-disk-image} 我们就可以像这样简化先前的 @code{image} 声明："

msgid "This will give the exact same @code{image} instantiation but the @code{image} declaration is simpler."
msgstr "这将会有一模一样的 @code{image} 实例化，不过 @code{image} 声明更加简单。"

msgid "The @command{guix system image} command can, as we saw above, take a file containing an @code{image} declaration as argument and produce an actual disk image from it.  The same command can also handle a file containing an @code{operating-system} declaration as argument.  In that case, how is the @code{operating-system} turned into an image?"
msgstr "正如我们在上面看到的那样，@command{guix system image} 命令可以将含有 @code{image} 声明的文件作为参数，从中产生一个磁盘镜像。同样的命令也可以操纵含有 @code{operating-system} 声明的文件作为参数。在那种情况下，@code{operating-system} 如何变为镜像呢？"

msgid "That's where the @code{image-type} record intervenes.  This record defines how to transform an @code{operating-system} record into an @code{image} record."
msgstr "那是 @code{image-type} 记录干预的地方。这个记录定义了 @code{operating-system} 记录如何转化为 @code{image} 记录。"

msgid "{Data Type} image-type"
msgstr "{数据类型} image-type"

msgid "This is the data type representing an image-type."
msgstr "这是表示镜像类别的数据类型。"

msgid "The image-type name as a mandatory symbol, @code{'efi32-raw} for instance."
msgstr "镜像类型名称是强制性的符号，比如说 @code{'efi32-raw}。"

msgid ""
"wsl --import Guix ./guix ./wsl2-image.tar.gz\n"
"wsl -d Guix\n"
msgstr ""
"wsl --import Guix ./guix ./wsl2-image.tar.gz\n"
"wsl -d Guix\n"

msgid "guix system image gnu/system/images/pine64.scm\n"
msgstr "guix system image gnu/system/images/pine64.scm\n"

msgid "$ guix system image --image-type=pine64-raw my-pine.scm\n"
msgstr "$ guix system image --image-type=pine64-raw my-pine.scm\n"

msgid "guix install glibc:debug guile:debug\n"
msgstr "guix install glibc:debug guile:debug\n"

msgid "(gdb) set debug-file-directory ~/.guix-profile/lib/debug\n"
msgstr "(gdb) set debug-file-directory ~/.guix-profile/lib/debug\n"

msgid ""
"guile\n"
"(use-modules (gdb))\n"
"(execute (string-append \"set debug-file-directory \"\n"
"                        (or (getenv \"GDB_DEBUG_FILE_DIRECTORY\")\n"
"                            \"~/.guix-profile/lib/debug\")))\n"
"end\n"
msgstr ""
"guile\n"
"(use-modules (gdb))\n"
"(execute (string-append \"set debug-file-directory \"\n"
"                        (or (getenv \"GDB_DEBUG_FILE_DIRECTORY\")\n"
"                            \"~/.guix-profile/lib/debug\")))\n"
"end\n"

msgid ""
"(gdb) bt\n"
"#0  0x00007ffff5f92190 in g_getenv ()\n"
"   from /gnu/store/@dots{}-glib-2.62.6/lib/libglib-2.0.so.0\n"
"#1  0x00007ffff608a7d6 in gobject_init_ctor ()\n"
"   from /gnu/store/@dots{}-glib-2.62.6/lib/libgobject-2.0.so.0\n"
"#2  0x00007ffff7fe275a in call_init (l=<optimized out>, argc=argc@@entry=1, argv=argv@@entry=0x7fffffffcfd8,\n"
"    env=env@@entry=0x7fffffffcfe8) at dl-init.c:72\n"
"#3  0x00007ffff7fe2866 in call_init (env=0x7fffffffcfe8, argv=0x7fffffffcfd8, argc=1, l=<optimized out>)\n"
"    at dl-init.c:118\n"
msgstr ""
"(gdb) bt\n"
"#0  0x00007ffff5f92190 in g_getenv ()\n"
"   from /gnu/store/@dots{}-glib-2.62.6/lib/libglib-2.0.so.0\n"
"#1  0x00007ffff608a7d6 in gobject_init_ctor ()\n"
"   from /gnu/store/@dots{}-glib-2.62.6/lib/libgobject-2.0.so.0\n"
"#2  0x00007ffff7fe275a in call_init (l=<optimized out>, argc=argc@@entry=1, argv=argv@@entry=0x7fffffffcfd8,\n"
"    env=env@@entry=0x7fffffffcfe8) at dl-init.c:72\n"
"#3  0x00007ffff7fe2866 in call_init (env=0x7fffffffcfe8, argv=0x7fffffffcfd8, argc=1, l=<optimized out>)\n"
"    at dl-init.c:118\n"

msgid ""
"$ gdb --args sh -c 'exec inkscape'\n"
"@dots{}\n"
"(gdb) b g_getenv\n"
"Function \"g_getenv\" not defined.\n"
"Make breakpoint pending on future shared library load? (y or [n]) y\n"
"Breakpoint 1 (g_getenv) pending.\n"
"(gdb) r\n"
"Starting program: /gnu/store/@dots{}-profile/bin/sh -c exec\\ inkscape\n"
"@dots{}\n"
"(gdb) bt\n"
"#0  g_getenv (variable=variable@@entry=0x7ffff60c7a2e \"GOBJECT_DEBUG\") at ../glib-2.62.6/glib/genviron.c:252\n"
"#1  0x00007ffff608a7d6 in gobject_init () at ../glib-2.62.6/gobject/gtype.c:4380\n"
"#2  gobject_init_ctor () at ../glib-2.62.6/gobject/gtype.c:4493\n"
"#3  0x00007ffff7fe275a in call_init (l=<optimized out>, argc=argc@@entry=3, argv=argv@@entry=0x7fffffffd088,\n"
"    env=env@@entry=0x7fffffffd0a8) at dl-init.c:72\n"
"@dots{}\n"
msgstr ""
"$ gdb --args sh -c 'exec inkscape'\n"
"@dots{}\n"
"(gdb) b g_getenv\n"
"Function \"g_getenv\" not defined.\n"
"Make breakpoint pending on future shared library load? (y or [n]) y\n"
"Breakpoint 1 (g_getenv) pending.\n"
"(gdb) r\n"
"Starting program: /gnu/store/@dots{}-profile/bin/sh -c exec\\ inkscape\n"
"@dots{}\n"
"(gdb) bt\n"
"#0  g_getenv (variable=variable@@entry=0x7ffff60c7a2e \"GOBJECT_DEBUG\") at ../glib-2.62.6/glib/genviron.c:252\n"
"#1  0x00007ffff608a7d6 in gobject_init () at ../glib-2.62.6/gobject/gtype.c:4380\n"
"#2  gobject_init_ctor () at ../glib-2.62.6/gobject/gtype.c:4493\n"
"#3  0x00007ffff7fe275a in call_init (l=<optimized out>, argc=argc@@entry=3, argv=argv@@entry=0x7fffffffd088,\n"
"    env=env@@entry=0x7fffffffd0a8) at dl-init.c:72\n"
"@dots{}\n"

msgid "guix search texlive-\\(scheme\\|collection\\) | recsel -p name,description\n"
msgstr "guix search texlive-\\(scheme\\|collection\\) | recsel -p name,description\n"

msgid ""
"doc.tex: File `tikz.sty' not found.\n"
"doc.tex:7: Emergency stop.\n"
msgstr ""
"doc.tex: File `tikz.sty' not found.\n"
"doc.tex:7: Emergency stop.\n"

msgid ""
"kpathsea: Running mktexmf phvr7t\n"
"! I can't find file `phvr7t'.\n"
msgstr ""
"kpathsea: Running mktexmf phvr7t\n"
"! I can't find file `phvr7t'.\n"

msgid ""
"$ guix search texlive tikz\n"
"name: texlive-pgf\n"
"version: 59745\n"
"@dots{}\n"
msgstr ""
"$ guix search texlive tikz\n"
"name: texlive-pgf\n"
"version: 59745\n"
"@dots{}\n"

msgid ""
"$ tlmgr info phvr7t\n"
"tlmgr: cannot find package phvr7t, searching for other matches:\n"
"\n"
msgstr ""
"$ tlmgr info phvr7t\n"
"tlmgr: cannot find package phvr7t, searching for other matches:\n"
"\n"

msgid ""
"Packages containing `phvr7t' in their title/description:\n"
"\n"
msgstr ""
"Packages containing `phvr7t' in their title/description:\n"
"\n"

msgid ""
"Packages containing files matching `phvr7t':\n"
"helvetic:\n"
"        texmf-dist/fonts/tfm/adobe/helvetic/phvr7t.tfm\n"
"        texmf-dist/fonts/tfm/adobe/helvetic/phvr7tn.tfm\n"
"        texmf-dist/fonts/vf/adobe/helvetic/phvr7t.vf\n"
"        texmf-dist/fonts/vf/adobe/helvetic/phvr7tn.vf\n"
"tex4ht:\n"
"        texmf-dist/tex4ht/ht-fonts/alias/adobe/helvetic/phvr7t.htf\n"
msgstr ""
"Packages containing files matching `phvr7t':\n"
"helvetic:\n"
"        texmf-dist/fonts/tfm/adobe/helvetic/phvr7t.tfm\n"
"        texmf-dist/fonts/tfm/adobe/helvetic/phvr7tn.tfm\n"
"        texmf-dist/fonts/vf/adobe/helvetic/phvr7t.vf\n"
"        texmf-dist/fonts/vf/adobe/helvetic/phvr7tn.vf\n"
"tex4ht:\n"
"        texmf-dist/tex4ht/ht-fonts/alias/adobe/helvetic/phvr7t.htf\n"

msgid "guix build bash --no-grafts\n"
msgstr "guix build bash --no-grafts\n"

msgid "guix build bash\n"
msgstr "guix build bash\n"

msgid "guix gc -R $(readlink -f ~/.guix-profile) | grep bash\n"
msgstr "guix gc -R $(readlink -f ~/.guix-profile) | grep bash\n"

msgid "guix gc -R $(guix system build my-config.scm) | grep bash\n"
msgstr "guix gc -R $(guix system build my-config.scm) | grep bash\n"

msgid "lsof | grep /gnu/store/.*bash\n"
msgstr "lsof | grep /gnu/store/.*bash\n"

msgid "./hex0-seed hex0_x86.hex0 hex0\n"
msgstr "./hex0-seed hex0_x86.hex0 hex0\n"

msgid ""
"sed 's/[;#].*$//g' hex0_x86.hex0 | xxd -r -p > hex0\n"
"chmod +x hex0\n"
msgstr ""
"sed 's/[;#].*$//g' hex0_x86.hex0 | xxd -r -p > hex0\n"
"chmod +x hex0\n"

msgid ""
"guix graph -t derivation \\\n"
"  -e '(@@@@ (gnu packages bootstrap) %bootstrap-gcc)' \\\n"
"  | dot -Tps > gcc.ps\n"
msgstr ""
"guix graph -t derivation \\\n"
"  -e '(@@@@ (gnu packages bootstrap) %bootstrap-gcc)' \\\n"
"  | dot -Tps > gcc.ps\n"

msgid ""
"guix graph -t derivation \\\n"
"  -e '(@@@@ (gnu packages bootstrap) %bootstrap-mes)' \\\n"
"  | dot -Tps > mes.ps\n"
msgstr ""
"guix graph -t derivation \\\n"
"  -e '(@@@@ (gnu packages bootstrap) %bootstrap-mes)' \\\n"
"  | dot -Tps > mes.ps\n"

msgid ""
"guix graph -t bag \\\n"
"  -e '(@@@@ (gnu packages commencement)\n"
"          glibc-final-with-bootstrap-bash)' | xdot -\n"
msgstr ""
"guix graph -t bag \\\n"
"  -e '(@@@@ (gnu packages commencement)\n"
"          glibc-final-with-bootstrap-bash)' | xdot -\n"

msgid "guix build bootstrap-tarballs\n"
msgstr "guix build bootstrap-tarballs\n"

msgid "guix build --target=armv5tel-linux-gnueabi bootstrap-tarballs\n"
msgstr "guix build --target=armv5tel-linux-gnueabi bootstrap-tarballs\n"

msgid "contributing.texi"
msgstr "contributing.zh_CN.texi"

msgid "The Nix-based software distributions, Nixpkgs and NixOS, have also been an inspiration for Guix."
msgstr "基于 Nix 的软件发行版 Nixpkgs 和 NixOS 也给 Guix 带来了灵感。"

msgid "GNU@tie{}Guix itself is a collective work with contributions from a number of people.  See the @file{AUTHORS} file in Guix for more information on these fine people.  The @file{THANKS} file lists people who have helped by reporting bugs, taking care of the infrastructure, providing artwork and themes, making suggestions, and more---thank you!"
msgstr "GNU@tie{}Guix 是一个许多人参与贡献的集体项目。在 Guix 的 @file{AUTHORS} 中能更多地了解这些大好人。@file{THANKS} 中列出了乐于助人者们：报告程序错误、维护基建、艺术创作，提出建议等等——谢谢你们！"

msgid "license, GNU Free Documentation License"
msgstr "许可证，GNU Free Documentation License"

msgid "fdl-1.3.texi"
msgstr "fdl-1.3.texi"
