The translation is temporarily closed for contributions due to maintenance, please come back later.
The translation was automatically locked due to following alerts: Could not update the repository.
Zen

Source string Source string

569/10000 · 569

This translation is currently locked.

English Actions
@xref{Package Modules,,, guix, GNU Guix Reference Manual}, for info on modules that define packages.
Going further
Scheme is a language that has been widely used to teach programming and you'll find plenty of material using it as a vehicle. Here's a selection of documents to learn more about Scheme:
@uref{https://spritely.institute/static/papers/scheme-primer.html, @i{A Scheme Primer}}, by Christine Lemmer-Webber and the Spritely Institute.
@uref{http://www.troubleshooters.com/codecorn/scheme_guile/hello.htm, @i{Scheme at a Glance}}, by Steve Litt.
@uref{https://sarabander.github.io/sicp/, @i{Structure and Interpretation of Computer Programs}}, by Harold Abelson and Gerald Jay Sussman, with Julie Sussman. Colloquially known as ``SICP'', this book is a reference.
You can also install it and read it from your computer:
guix install sicp info-reader
info sicp
You'll find more books, tutorials and other resources at @url{https://schemers.org/}.
packaging
This chapter is dedicated to teaching you how to add packages to the collection of packages that come with GNU Guix. This involves writing package definitions in Guile Scheme, organizing them in package modules, and building them.
GNU Guix stands out as the @emph{hackable} package manager, mostly because it uses @uref{https://www.gnu.org/software/guile/, GNU Guile}, a powerful high-level programming language, one of the @uref{https://en.wikipedia.org/wiki/Scheme_%28programming_language%29, Scheme} dialects from the @uref{https://en.wikipedia.org/wiki/Lisp_%28programming_language%29, Lisp family}.
Package definitions are also written in Scheme, which empowers Guix in some very unique ways, unlike most other package managers that use shell scripts or simple languages.
Use functions, structures, macros and all of Scheme expressiveness for your package definitions.
Inheritance makes it easy to customize a package by inheriting from it and modifying only what is needed.
Batch processing: the whole package collection can be parsed, filtered and processed. Building a headless server with all graphical interfaces stripped out? It's possible. Want to rebuild everything from source using specific compiler optimization flags? Pass the @code{#:make-flags "..."} argument to the list of packages. It wouldn't be a stretch to think @uref{https://wiki.gentoo.org/wiki/USE_flag, Gentoo USE flags} here, but this goes even further: the changes don't have to be thought out beforehand by the packager, they can be @emph{programmed} by the user!
The following tutorial covers all the basics around package creation with Guix. It does not assume much knowledge of the Guix system nor of the Lisp language. The reader is only expected to be familiar with the command line and to have some basic programming knowledge.
The ``Defining Packages'' section of the manual introduces the basics of Guix packaging (@pxref{Defining Packages,,, guix, GNU Guix Reference Manual}). In the following section, we will partly go over those basics again.
GNU@tie{}Hello is a dummy project that serves as an idiomatic example for packaging. It uses the GNU build system (@code{./configure && make && make install}). Guix already provides a package definition which is a perfect example to start with. You can look up its declaration with @code{guix edit hello} from the command line. Let's see how it looks:
(define-public hello
(package
(name "hello")
(version "2.10")
(source (origin
(method url-fetch)
(uri (string-append "mirror://gnu/hello/hello-" version
".tar.gz"))
(sha256
(base32
"0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
(build-system gnu-build-system)
(synopsis "Hello, GNU world: An example GNU package")
(description
"GNU Hello prints the message \"Hello, world!\" and then exits. It
serves as an example of standard GNU coding practices. As such, it supports
command-line arguments, multiple languages, and so on.")
(home-page "https://www.gnu.org/software/hello/")
(license gpl3+)))
As you can see, most of it is rather straightforward. But let's review the fields together:
name
The project name. Using Scheme conventions, we prefer to keep it lower case, without underscore and using dash-separated words.
source
This field contains a description of the source code origin. The @code{origin} record contains these fields:
The method, here @code{url-fetch} to download via HTTP/FTP, but other methods
exist, such as @code{git-fetch} for Git repositories.
The URI, which is typically some @code{https://} location for @code{url-fetch}. Here
the special `mirror://gnu` refers to a set of well known locations, all of which can be used by Guix to fetch the source, should some of them fail.
The @code{sha256} checksum of the requested file. This is essential to ensure
the source is not corrupted. Note that Guix works with base32 strings, hence the call to the @code{base32} function.

Loading…

No matching activity found.
Browse all string changes

Things to check

Ellipsis

The string uses three dots (...) instead of an ellipsis character (…)

Reset

Glossary

English English
No related strings found in the glossary.

String information

Source string description
type: itemize
Flags
read-only
Source string location
guix-git/doc/guix-cookbook.texi:543
String age
3 years ago
Last updated
10 months ago
Source string age
3 years ago
Translation file
po/doc/guix-cookbook.pot, string 200