5 @setfilename guix-cookbook.info
6 @documentencoding UTF-8
7 @settitle GNU Guix Cookbook
11 Copyright @copyright{} 2019 Ricardo Wurmus@*
12 Copyright @copyright{} 2019 Efraim Flashner@*
13 Copyright @copyright{} 2019 Pierre Neidhardt@*
14 Copyright @copyright{} 2020 Oleg Pykhalov@*
15 Copyright @copyright{} 2020 Matthew Brooks@*
16 Copyright @copyright{} 2020 Marcin Karpezo@*
17 Copyright @copyright{} 2020 Brice Waegeneire@*
18 Copyright @copyright{} 2020 André Batista@*
19 Copyright @copyright{} 2020 Christopher Lemmer Webber
21 Permission is granted to copy, distribute and/or modify this document
22 under the terms of the GNU Free Documentation License, Version 1.3 or
23 any later version published by the Free Software Foundation; with no
24 Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A
25 copy of the license is included in the section entitled ``GNU Free
26 Documentation License''.
29 @dircategory System administration
31 * Guix cookbook: (guix-cookbook). Tutorials and examples for GNU Guix.
35 @title GNU Guix Cookbook
36 @subtitle Tutorials and examples for using the GNU Guix Functional Package Manager
37 @author The GNU Guix Developers
40 @vskip 0pt plus 1filll
47 @c *********************************************************************
49 @top GNU Guix Cookbook
51 This document presents tutorials and detailed examples for GNU@tie{}Guix, a
52 functional package management tool written for the GNU system. Please
53 @pxref{Top,,, guix, GNU Guix reference manual} for details about the system,
54 its API, and related concepts.
56 @c TRANSLATORS: You can replace the following paragraph with information on
57 @c how to join your own translation team and how to report issues with the
59 If you would like to translate this document in your native language, consider
60 joining the @uref{https://translationproject.org/domain/guix-cookbook.html,
64 * Scheme tutorials:: Meet your new favorite language!
65 * Packaging:: Packaging tutorials
66 * System Configuration:: Customizing the GNU System
67 * Advanced package management:: Power to the users!
68 * Environment management:: Control environment
70 * Acknowledgments:: Thanks!
71 * GNU Free Documentation License:: The license of this document.
72 * Concept Index:: Concepts.
75 --- The Detailed Node Listing ---
79 * A Scheme Crash Course:: Learn the basics of Scheme
83 * Packaging Tutorial:: Let's add a package to Guix!
87 * Customizing the Kernel:: Creating and using a custom Linux kernel
93 @c *********************************************************************
94 @node Scheme tutorials
95 @chapter Scheme tutorials
97 GNU@tie{}Guix is written in the general purpose programming language Scheme,
98 and many of its features can be accessed and manipulated programmatically.
99 You can use Scheme to generate package definitions, to modify them, to build
100 them, to deploy whole operating systems, etc.
102 Knowing the basics of how to program in Scheme will unlock many of the
103 advanced features Guix provides --- and you don't even need to be an
104 experienced programmer to use them!
108 @node A Scheme Crash Course
109 @section A Scheme Crash Course
111 @cindex Scheme, crash course
113 Guix uses the Guile implementation of Scheme. To start playing with the
114 language, install it with @code{guix install guile} and start a
115 @dfn{REPL}---short for @uref{https://en.wikipedia.org/wiki/Read%E2%80%93eval%E2%80%93print_loop,
116 @dfn{read-eval-print loop}}---by running @code{guile} from the command line.
118 Alternatively you can also run @code{guix environment --ad-hoc guile -- guile}
119 if you'd rather not have Guile installed in your user profile.
121 In the following examples, lines show what you would type at the REPL;
122 lines starting with ``@result{}'' show evaluation results, while lines
123 starting with ``@print{}'' show things that get printed. @xref{Using Guile
124 Interactively,,, guile, GNU Guile Reference Manual}, for more details on the
129 Scheme syntax boils down to a tree of expressions (or @emph{s-expression} in
130 Lisp lingo). An expression can be a literal such as numbers and strings, or a
131 compound which is a parenthesized list of compounds and literals. @code{#t}
132 and @code{#f} stand for the Booleans ``true'' and ``false'', respectively.
134 Examples of valid expressions:
138 @result{} "Hello World!"
143 (display (string-append "Hello " "Guix" "\n"))
145 @result{} #<unspecified>
149 This last example is a function call nested in another function call. When a
150 parenthesized expression is evaluated, the first term is the function and the
151 rest are the arguments passed to the function. Every function returns the
152 last evaluated expression as its return value.
155 Anonymous functions are declared with the @code{lambda} term:
159 @result{} #<procedure 120e348 at <unknown port>:24:0 (x)>
162 The above procedure returns the square of its argument. Since everything is
163 an expression, the @code{lambda} expression returns an anonymous procedure,
164 which can in turn be applied to an argument:
167 ((lambda (x) (* x x)) 3)
172 Anything can be assigned a global name with @code{define}:
176 (define square (lambda (x) (* x x)))
182 Procedures can be defined more concisely with the following syntax:
185 (define (square x) (* x x))
189 A list structure can be created with the @code{list} procedure:
197 The @dfn{quote} disables evaluation of a parenthesized expression: the
198 first term is not called over the other terms (@pxref{Expression Syntax,
199 quote,, guile, GNU Guile Reference Manual}). Thus it effectively
200 returns a list of terms.
203 '(display (string-append "Hello " "Guix" "\n"))
204 @result{} (display (string-append "Hello " "Guix" "\n"))
211 The @dfn{quasiquote} disables evaluation of a parenthesized expression
212 until @dfn{unquote} (a comma) re-enables it. Thus it provides us with
213 fine-grained control over what is evaluated and what is not.
216 `(2 a 5 7 (2 ,a 5 ,(+ a 4)))
217 @result{} (2 a 5 7 (2 3 5 7))
220 Note that the above result is a list of mixed elements: numbers, symbols (here
221 @code{a}) and the last element is a list itself.
224 Multiple variables can be named locally with @code{let} (@pxref{Local
225 Bindings,,, guile, GNU Guile Reference Manual}):
238 @error{} In procedure module-lookup: Unbound variable: y
241 Use @code{let*} to allow later variable declarations to refer to earlier
252 The keyword syntax is @code{#:}; it is used to create unique identifiers.
253 @pxref{Keywords,,, guile, GNU Guile Reference Manual}.
256 The percentage @code{%} is typically used for read-only global variables in
257 the build stage. Note that it is merely a convention, like @code{_} in C.
258 Scheme treats @code{%} exactly the same as any other letter.
261 Modules are created with @code{define-module} (@pxref{Creating Guile
262 Modules,,, guile, GNU Guile Reference Manual}). For instance
265 (define-module (guix build-system ruby)
266 #:use-module (guix store)
271 defines the module @code{guix build-system ruby} which must be located in
272 @file{guix/build-system/ruby.scm} somewhere in the Guile load path. It
273 depends on the @code{(guix store)} module and it exports two variables,
274 @code{ruby-build} and @code{ruby-build-system}.
277 For a more detailed introduction, check out
278 @uref{http://www.troubleshooters.com/codecorn/scheme_guile/hello.htm, Scheme
279 at a Glance}, by Steve Litt.
281 One of the reference Scheme books is the seminal ``Structure and
282 Interpretation of Computer Programs'', by Harold Abelson and Gerald Jay
283 Sussman, with Julie Sussman. You'll find a
284 @uref{https://mitpress.mit.edu/sites/default/files/sicp/index.html, free copy
285 online}, together with
286 @uref{https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-001-structure-and-interpretation-of-computer-programs-spring-2005/video-lectures/,
287 videos of the lectures by the authors}. The book is available in Texinfo
288 format as the @code{sicp} Guix package. Go ahead, run @code{guix install
289 sicp} and start reading with @code{info sicp} (@pxref{,,, sicp, Structure and Interpretation of Computer Programs}).
290 An @uref{https://sarabander.github.io/sicp/, unofficial ebook is also
293 You'll find more books, tutorials and other resources at
294 @url{https://schemers.org/}.
297 @c *********************************************************************
303 This chapter is dedicated to teaching you how to add packages to the
304 collection of packages that come with GNU Guix. This involves writing package
305 definitions in Guile Scheme, organizing them in package modules, and building
309 * Packaging Tutorial:: A tutorial on how to add packages to Guix.
312 @node Packaging Tutorial
313 @section Packaging Tutorial
315 GNU Guix stands out as the @emph{hackable} package manager, mostly because it
316 uses @uref{https://www.gnu.org/software/guile/, GNU Guile}, a powerful
317 high-level programming language, one of the
318 @uref{https://en.wikipedia.org/wiki/Scheme_%28programming_language%29, Scheme}
320 @uref{https://en.wikipedia.org/wiki/Lisp_%28programming_language%29, Lisp family}.
322 Package definitions are also written in Scheme, which empowers Guix in some
323 very unique ways, unlike most other package managers that use shell scripts or
328 Use functions, structures, macros and all of Scheme expressiveness for your
332 Inheritance makes it easy to customize a package by inheriting from it and
333 modifying only what is needed.
336 Batch processing: the whole package collection can be parsed, filtered and
337 processed. Building a headless server with all graphical interfaces stripped
338 out? It's possible. Want to rebuild everything from source using specific
339 compiler optimization flags? Pass the @code{#:make-flags "..."} argument to
340 the list of packages. It wouldn't be a stretch to think
341 @uref{https://wiki.gentoo.org/wiki/USE_flag, Gentoo USE flags} here, but this
342 goes even further: the changes don't have to be thought out beforehand by the
343 packager, they can be @emph{programmed} by the user!
346 The following tutorial covers all the basics around package creation with Guix.
347 It does not assume much knowledge of the Guix system nor of the Lisp language.
348 The reader is only expected to be familiar with the command line and to have some
349 basic programming knowledge.
351 @node A ``Hello World'' package
352 @subsection A ``Hello World'' package
354 The ``Defining Packages'' section of the manual introduces the basics of Guix
355 packaging (@pxref{Defining Packages,,, guix, GNU Guix Reference Manual}). In
356 the following section, we will partly go over those basics again.
358 GNU@tie{}Hello is a dummy project that serves as an idiomatic example for
359 packaging. It uses the GNU build system (@code{./configure && make && make
360 install}). Guix already provides a package definition which is a perfect
361 example to start with. You can look up its declaration with @code{guix edit
362 hello} from the command line. Let's see how it looks:
371 (uri (string-append "mirror://gnu/hello/hello-" version
375 "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
376 (build-system gnu-build-system)
377 (synopsis "Hello, GNU world: An example GNU package")
379 "GNU Hello prints the message \"Hello, world!\" and then exits. It
380 serves as an example of standard GNU coding practices. As such, it supports
381 command-line arguments, multiple languages, and so on.")
382 (home-page "https://www.gnu.org/software/hello/")
386 As you can see, most of it is rather straightforward. But let's review the
391 The project name. Using Scheme conventions, we prefer to keep it
392 lower case, without underscore and using dash-separated words.
395 This field contains a description of the source code origin. The
396 @code{origin} record contains these fields:
399 @item The method, here @code{url-fetch} to download via HTTP/FTP, but other methods
400 exist, such as @code{git-fetch} for Git repositories.
401 @item The URI, which is typically some @code{https://} location for @code{url-fetch}. Here
402 the special `mirror://gnu` refers to a set of well known locations, all of
403 which can be used by Guix to fetch the source, should some of them fail.
404 @item The @code{sha256} checksum of the requested file. This is essential to ensure
405 the source is not corrupted. Note that Guix works with base32 strings,
406 hence the call to the @code{base32} function.
411 This is where the power of abstraction provided by the Scheme language really
412 shines: in this case, the @code{gnu-build-system} abstracts away the famous
413 @code{./configure && make && make install} shell invocations. Other build
414 systems include the @code{trivial-build-system} which does not do anything and
415 requires from the packager to program all the build steps, the
416 @code{python-build-system}, the @code{emacs-build-system}, and many more
417 (@pxref{Build Systems,,, guix, GNU Guix Reference Manual}).
420 It should be a concise summary of what the package does. For many packages a
421 tagline from the project's home page can be used as the synopsis.
424 Same as for the synopsis, it's fine to re-use the project description from the
425 homepage. Note that Guix uses Texinfo syntax.
428 Use HTTPS if available.
431 See @code{guix/licenses.scm} in the project source for a full list of
435 Time to build our first package! Nothing fancy here for now: we will stick to a
436 dummy @code{my-hello}, a copy of the above declaration.
438 As with the ritualistic ``Hello World'' taught with most programming languages,
439 this will possibly be the most ``manual'' approach. We will work out an ideal
440 setup later; for now we will go the simplest route.
442 Save the following to a file @file{my-hello.scm}.
445 (use-modules (guix packages)
447 (guix build-system gnu)
455 (uri (string-append "mirror://gnu/hello/hello-" version
459 "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
460 (build-system gnu-build-system)
461 (synopsis "Hello, Guix world: An example custom Guix package")
463 "GNU Hello prints the message \"Hello, world!\" and then exits. It
464 serves as an example of standard GNU coding practices. As such, it supports
465 command-line arguments, multiple languages, and so on.")
466 (home-page "https://www.gnu.org/software/hello/")
470 We will explain the extra code in a moment.
472 Feel free to play with the different values of the various fields. If you
473 change the source, you'll need to update the checksum. Indeed, Guix refuses to
474 build anything if the given checksum does not match the computed checksum of the
475 source code. To obtain the correct checksum of the package declaration, we
476 need to download the source, compute the sha256 checksum and convert it to
479 Thankfully, Guix can automate this task for us; all we need is to provide the
482 @c TRANSLATORS: This is example shell output.
484 $ guix download mirror://gnu/hello/hello-2.10.tar.gz
486 Starting download of /tmp/guix-file.JLYgL7
487 From https://ftpmirror.gnu.org/gnu/hello/hello-2.10.tar.gz...
488 following redirection to `https://mirror.ibcp.fr/pub/gnu/hello/hello-2.10.tar.gz'...
489 …10.tar.gz 709KiB 2.5MiB/s 00:00 [##################] 100.0%
490 /gnu/store/hbdalsf5lpf01x4dcknwx6xbn6n5km6k-hello-2.10.tar.gz
491 0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i
494 In this specific case the output tells us which mirror was chosen.
495 If the result of the above command is not the same as in the above snippet,
496 update your @code{my-hello} declaration accordingly.
498 Note that GNU package tarballs come with an OpenPGP signature, so you
499 should definitely check the signature of this tarball with `gpg` to
500 authenticate it before going further:
502 @c TRANSLATORS: This is example shell output.
504 $ guix download mirror://gnu/hello/hello-2.10.tar.gz.sig
506 Starting download of /tmp/guix-file.03tFfb
507 From https://ftpmirror.gnu.org/gnu/hello/hello-2.10.tar.gz.sig...
508 following redirection to `https://ftp.igh.cnrs.fr/pub/gnu/hello/hello-2.10.tar.gz.sig'...
509 ….tar.gz.sig 819B 1.2MiB/s 00:00 [##################] 100.0%
510 /gnu/store/rzs8wba9ka7grrmgcpfyxvs58mly0sx6-hello-2.10.tar.gz.sig
511 0q0v86n3y38z17rl146gdakw9xc4mcscpk8dscs412j22glrv9jf
512 $ gpg --verify /gnu/store/rzs8wba9ka7grrmgcpfyxvs58mly0sx6-hello-2.10.tar.gz.sig /gnu/store/hbdalsf5lpf01x4dcknwx6xbn6n5km6k-hello-2.10.tar.gz
513 gpg: Signature made Sun 16 Nov 2014 01:08:37 PM CET
514 gpg: using RSA key A9553245FDE9B739
515 gpg: Good signature from "Sami Kerola <kerolasa@@iki.fi>" [unknown]
516 gpg: aka "Sami Kerola (http://www.iki.fi/kerolasa/) <kerolasa@@iki.fi>" [unknown]
517 gpg: WARNING: This key is not certified with a trusted signature!
518 gpg: There is no indication that the signature belongs to the owner.
519 Primary key fingerprint: 8ED3 96E3 7E38 D471 A005 30D3 A955 3245 FDE9 B739
522 You can then happily run
524 @c TRANSLATORS: Do not translate this command
526 $ guix package --install-from-file=my-hello.scm
529 You should now have @code{my-hello} in your profile!
531 @c TRANSLATORS: Do not translate this command
533 $ guix package --list-installed=my-hello
535 /gnu/store/f1db2mfm8syb8qvc357c53slbvf1g9m9-my-hello-2.10
538 We've gone as far as we could without any knowledge of Scheme. Before moving
539 on to more complex packages, now is the right time to brush up on your Scheme
540 knowledge. @pxref{A Scheme Crash Course} to get up to speed.
545 In the rest of this chapter we will rely on some basic Scheme
546 programming knowledge. Now let's detail the different possible setups
547 for working on Guix packages.
549 There are several ways to set up a Guix packaging environment.
551 We recommend you work directly on the Guix source checkout since it makes it
552 easier for everyone to contribute to the project.
554 But first, let's look at other possibilities.
557 @subsubsection Local file
559 This is what we previously did with @samp{my-hello}. With the Scheme basics we've
560 covered, we are now able to explain the leading chunks. As stated in @code{guix
564 -f, --install-from-file=FILE
565 install the package that the code within FILE
569 Thus the last expression @emph{must} return a package, which is the case in our
572 The @code{use-modules} expression tells which of the modules we need in the file.
573 Modules are a collection of values and procedures. They are commonly called
574 ``libraries'' or ``packages'' in other programming languages.
576 @node @samp{GUIX_PACKAGE_PATH}
577 @subsubsection @samp{GUIX_PACKAGE_PATH}
579 @emph{Note: Starting from Guix 0.16, the more flexible Guix @dfn{channels} are the
580 preferred way and supersede @samp{GUIX_PACKAGE_PATH}. See next section.}
582 It can be tedious to specify the file from the command line instead of simply
583 calling @code{guix package --install my-hello} as you would do with the official
586 Guix makes it possible to streamline the process by adding as many ``package
587 declaration directories'' as you want.
589 Create a directory, say @file{~./guix-packages} and add it to the @samp{GUIX_PACKAGE_PATH}
590 environment variable:
593 $ mkdir ~/guix-packages
594 $ export GUIX_PACKAGE_PATH=~/guix-packages
597 To add several directories, separate them with a colon (@code{:}).
599 Our previous @samp{my-hello} needs some adjustments though:
602 (define-module (my-hello)
603 #:use-module (guix licenses)
604 #:use-module (guix packages)
605 #:use-module (guix build-system gnu)
606 #:use-module (guix download))
608 (define-public my-hello
614 (uri (string-append "mirror://gnu/hello/hello-" version
618 "0ssi1wpaf7plaswqqjwigppsg5fyh99vdlb9kzl7c9lng89ndq1i"))))
619 (build-system gnu-build-system)
620 (synopsis "Hello, Guix world: An example custom Guix package")
622 "GNU Hello prints the message \"Hello, world!\" and then exits. It
623 serves as an example of standard GNU coding practices. As such, it supports
624 command-line arguments, multiple languages, and so on.")
625 (home-page "https://www.gnu.org/software/hello/")
629 Note that we have assigned the package value to an exported variable name with
630 @code{define-public}. This is effectively assigning the package to the @code{my-hello}
631 variable so that it can be referenced, among other as dependency of other
634 If you use @code{guix package --install-from-file=my-hello.scm} on the above file, it
635 will fail because the last expression, @code{define-public}, does not return a
636 package. If you want to use @code{define-public} in this use-case nonetheless, make
637 sure the file ends with an evaluation of @code{my-hello}:
641 (define-public my-hello
648 This last example is not very typical.
650 Now @samp{my-hello} should be part of the package collection like all other official
651 packages. You can verify this with:
654 $ guix package --show=my-hello
658 @subsubsection Guix channels
660 Guix 0.16 features channels, which is very similar to @samp{GUIX_PACKAGE_PATH} but
661 provides better integration and provenance tracking. Channels are not
662 necessarily local, they can be maintained as a public Git repository for
663 instance. Of course, several channels can be used at the same time.
665 @xref{Channels,,, guix, GNU Guix Reference Manual} for setup details.
667 @node Direct checkout hacking
668 @subsubsection Direct checkout hacking
670 Working directly on the Guix project is recommended: it reduces the friction
671 when the time comes to submit your changes upstream to let the community benefit
674 Unlike most software distributions, the Guix repository holds in one place both
675 the tooling (including the package manager) and the package definitions. This
676 choice was made so that it would give developers the flexibility to modify the
677 API without breakage by updating all packages at the same time. This reduces
680 Check out the official @uref{https://git-scm.com/, Git} repository:
683 $ git clone https://git.savannah.gnu.org/git/guix.git
686 In the rest of this article, we use @samp{$GUIX_CHECKOUT} to refer to the location of
690 Follow the instructions in the manual (@pxref{Contributing,,, guix, GNU Guix
691 Reference Manual}) to set up the repository environment.
693 Once ready, you should be able to use the package definitions from the
694 repository environment.
696 Feel free to edit package definitions found in @samp{$GUIX_CHECKOUT/gnu/packages}.
698 The @samp{$GUIX_CHECKOUT/pre-inst-env} script lets you use @samp{guix} over the package
699 collection of the repository (@pxref{Running Guix Before It Is
700 Installed,,, guix, GNU Guix Reference Manual}).
704 Search packages, such as Ruby:
708 $ ./pre-inst-env guix package --list-available=ruby
709 ruby 1.8.7-p374 out gnu/packages/ruby.scm:119:2
710 ruby 2.1.6 out gnu/packages/ruby.scm:91:2
711 ruby 2.2.2 out gnu/packages/ruby.scm:39:2
715 Build a package, here Ruby version 2.1:
718 $ ./pre-inst-env guix build --keep-failed ruby@@2.1
719 /gnu/store/c13v73jxmj2nir2xjqaz5259zywsa9zi-ruby-2.1.6
723 Install it to your user profile:
726 $ ./pre-inst-env guix package --install ruby@@2.1
730 Check for common mistakes:
733 $ ./pre-inst-env guix lint ruby@@2.1
737 Guix strives at maintaining a high packaging standard; when contributing to the
738 Guix project, remember to
742 follow the coding style (@pxref{Coding Style,,, guix, GNU Guix Reference Manual}),
744 and review the check list from the manual (@pxref{Submitting Patches,,, guix, GNU Guix Reference Manual}).
747 Once you are happy with the result, you are welcome to send your contribution to
748 make it part of Guix. This process is also detailed in the manual. (@pxref{Contributing,,, guix, GNU Guix Reference Manual})
751 It's a community effort so the more join in, the better Guix becomes!
753 @node Extended example
754 @subsection Extended example
756 The above ``Hello World'' example is as simple as it goes. Packages can be more
757 complex than that and Guix can handle more advanced scenarios. Let's look at
758 another, more sophisticated package (slightly modified from the source):
761 (define-module (gnu packages version-control)
762 #:use-module ((guix licenses) #:prefix license:)
763 #:use-module (guix utils)
764 #:use-module (guix packages)
765 #:use-module (guix git-download)
766 #:use-module (guix build-system cmake)
767 #:use-module (gnu packages ssh)
768 #:use-module (gnu packages web)
769 #:use-module (gnu packages pkg-config)
770 #:use-module (gnu packages python)
771 #:use-module (gnu packages compression)
772 #:use-module (gnu packages tls))
774 (define-public my-libgit2
775 (let ((commit "e98d0a37c93574d2c6107bf7f31140b548c6a7bf")
779 (version (git-version "0.26.6" revision commit))
783 (url "https://github.com/libgit2/libgit2/")
785 (file-name (git-file-name name version))
788 "17pjvprmdrx4h6bb1hhc98w9qi6ki7yl57f090n9kbhswxqfs7s3"))
789 (patches (search-patches "libgit2-mtime-0.patch"))
790 (modules '((guix build utils)))
792 ;; Remove bundled software.
793 (delete-file-recursively "deps")
795 (build-system cmake-build-system)
796 (outputs '("out" "debug"))
798 `(#:tests? #t ; Run the test suite (this is the default)
799 #:configure-flags '("-DUSE_SHA1DC=ON") ; SHA-1 collision detection
801 (modify-phases %standard-phases
802 (add-after 'unpack 'fix-hardcoded-paths
804 (substitute* "tests/repo/init.c"
805 (("#!/bin/sh") (string-append "#!" (which "sh"))))
806 (substitute* "tests/clar/fs.h"
807 (("/bin/cp") (which "cp"))
808 (("/bin/rm") (which "rm")))
810 ;; Run checks more verbosely.
812 (lambda _ (invoke "./libgit2_clar" "-v" "-Q")))
813 (add-after 'unpack 'make-files-writable-for-tests
814 (lambda _ (for-each make-file-writable (find-files "." ".*")))))))
816 `(("libssh2" ,libssh2)
817 ("http-parser" ,http-parser)
818 ("python" ,python-wrapper)))
820 `(("pkg-config" ,pkg-config)))
822 ;; These two libraries are in 'Requires.private' in libgit2.pc.
823 `(("openssl" ,openssl)
825 (home-page "https://libgit2.github.com/")
826 (synopsis "Library providing Git core methods")
828 "Libgit2 is a portable, pure C implementation of the Git core methods
829 provided as a re-entrant linkable library with a solid API, allowing you to
830 write native speed custom Git applications in any language with bindings.")
831 ;; GPLv2 with linking exception
832 (license license:gpl2))))
835 (In those cases were you only want to tweak a few fields from a package
836 definition, you should rely on inheritance instead of copy-pasting everything.
839 Let's discuss those fields in depth.
841 @subsubsection @code{git-fetch} method
843 Unlike the @code{url-fetch} method, @code{git-fetch} expects a @code{git-reference} which takes
844 a Git repository and a commit. The commit can be any Git reference such as
845 tags, so if the @code{version} is tagged, then it can be used directly. Sometimes
846 the tag is prefixed with a @code{v}, in which case you'd use @code{(commit (string-append
849 To ensure that the source code from the Git repository is stored in a
850 directory with a descriptive name, we use @code{(file-name (git-file-name name
853 The @code{git-version} procedure can be used to derive the
854 version when packaging programs for a specific commit, following the
855 Guix contributor guidelines (@pxref{Version Numbers,,, guix, GNU Guix
858 How does one obtain the @code{sha256} hash that's in there, you ask? By
859 invoking @command{guix hash} on a checkout of the desired commit, along
863 git clone https://github.com/libgit2/libgit2/
869 @command{guix hash -rx} computes a SHA256 hash over the whole directory,
870 excluding the @file{.git} sub-directory (@pxref{Invoking guix hash,,,
871 guix, GNU Guix Reference Manual}).
873 In the future, @command{guix download} will hopefully be able to do
874 these steps for you, just like it does for regular downloads.
876 @subsubsection Snippets
878 Snippets are quoted (i.e. non-evaluated) Scheme code that are a means of patching
879 the source. They are a Guix-y alternative to the traditional @file{.patch} files.
880 Because of the quote, the code in only evaluated when passed to the Guix daemon
881 for building. There can be as many snippets as needed.
883 Snippets might need additional Guile modules which can be imported from the
884 @code{modules} field.
886 @subsubsection Inputs
888 First, a syntactic comment: See the quasi-quote / comma syntax?
892 `(("pkg-config" ,pkg-config)))
899 (list (list "pkg-config" pkg-config)))
902 You'll mostly see the former because it's shorter.
904 There are 3 different input types. In short:
908 Required for building but not runtime -- installing a package
909 through a substitute won't install these inputs.
911 Installed in the store but not in the profile, as well as being
912 present at build time.
913 @item propagated-inputs
914 Installed in the store and in the profile, as well as
915 being present at build time.
918 @xref{Package Reference,,, guix, GNU Guix Reference Manual} for more details.
920 The distinction between the various inputs is important: if a dependency can be
921 handled as an @emph{input} instead of a @emph{propagated input}, it should be done so, or
922 else it ``pollutes'' the user profile for no good reason.
924 For instance, a user installing a graphical program that depends on a
925 command line tool might only be interested in the graphical part, so there is no
926 need to force the command line tool into the user profile. The dependency is a
927 concern to the package, not to the user. @emph{Inputs} make it possible to handle
928 dependencies without bugging the user by adding undesired executable files (or
929 libraries) to their profile.
931 Same goes for @emph{native-inputs}: once the program is installed, build-time
932 dependencies can be safely garbage-collected.
933 It also matters when a substitute is available, in which case only the @emph{inputs}
934 and @emph{propagated inputs} will be fetched: the @emph{native inputs} are not required to
935 install a package from a substitute.
937 @subsubsection Outputs
939 Just like how a package can have multiple inputs, it can also produce multiple
942 Each output corresponds to a separate directory in the store.
944 The user can choose which output to install; this is useful to save space or
945 to avoid polluting the user profile with unwanted executables or libraries.
947 Output separation is optional. When the @code{outputs} field is left out, the
948 default and only output (the complete package) is referred to as @code{"out"}.
950 Typical separate output names include @code{debug} and @code{doc}.
952 It's advised to separate outputs only when you've shown it's worth it: if the
953 output size is significant (compare with @code{guix size}) or in case the package is
956 @subsubsection Build system arguments
958 The @code{arguments} is a keyword-value list used to configure the build process.
960 The simplest argument @code{#:tests?} can be used to disable the test suite when
961 building the package. This is mostly useful when the package does not feature
962 any test suite. It's strongly recommended to keep the test suite on if there is
965 Another common argument is @code{:make-flags}, which specifies a list of flags to
966 append when running make, as you would from the command line. For instance, the
970 #:make-flags (list (string-append "prefix=" (assoc-ref %outputs "out"))
977 $ make CC=gcc prefix=/gnu/store/...-<out>
980 This sets the C compiler to @code{gcc} and the @code{prefix} variable (the installation
981 directory in Make parlance) to @code{(assoc-ref %outputs "out")}, which is a build-stage
982 global variable pointing to the destination directory in the store (something like
983 @file{/gnu/store/...-my-libgit2-20180408}).
985 Similarly, it's possible to set the configure flags:
988 #:configure-flags '("-DUSE_SHA1DC=ON")
991 The @code{%build-inputs} variable is also generated in scope. It's an association
992 table that maps the input names to their store directories.
994 The @code{phases} keyword lists the sequential steps of the build system. Typically
995 phases include @code{unpack}, @code{configure}, @code{build}, @code{install} and @code{check}. To know
996 more about those phases, you need to work out the appropriate build system
997 definition in @samp{$GUIX_CHECKOUT/guix/build/gnu-build-system.scm}:
1000 (define %standard-phases
1001 ;; Standard build phases, as a list of symbol/procedure pairs.
1002 (let-syntax ((phases (syntax-rules ()
1003 ((_ p ...) `((p . ,p) ...)))))
1004 (phases set-SOURCE-DATE-EPOCH set-paths install-locale unpack
1007 patch-source-shebangs configure patch-generated-file-shebangs
1009 patch-shebangs strip
1011 validate-documentation-location
1012 delete-info-dir-file
1013 patch-dot-desktop-files
1014 install-license-files
1015 reset-gzip-timestamps
1016 compress-documentation)))
1022 (add-to-load-path "/path/to/guix/checkout")
1023 ,use (guix build gnu-build-system)
1024 (map first %standard-phases)
1025 @result{} (set-SOURCE-DATE-EPOCH set-paths install-locale unpack bootstrap patch-usr-bin-file patch-source-shebangs configure patch-generated-file-shebangs build check install patch-shebangs strip validate-runpath validate-documentation-location delete-info-dir-file patch-dot-desktop-files install-license-files reset-gzip-timestamps compress-documentation)
1028 If you want to know more about what happens during those phases, consult the
1029 associated procedures.
1031 For instance, as of this writing the definition of @code{unpack} for the GNU build
1035 (define* (unpack #:key source #:allow-other-keys)
1036 "Unpack SOURCE in the working directory, and change directory within the
1037 source. When SOURCE is a directory, copy it in a sub-directory of the current
1039 (if (file-is-directory? source)
1044 ;; Preserve timestamps (set to the Epoch) on the copied tree so that
1045 ;; things work deterministically.
1046 (copy-recursively source "."
1049 (if (string-suffix? ".zip" source)
1050 (invoke "unzip" source)
1051 (invoke "tar" "xvf" source))
1052 (chdir (first-subdirectory "."))))
1056 Note the @code{chdir} call: it changes the working directory to where the source was
1058 Thus every phase following the @code{unpack} will use the source as a working
1059 directory, which is why we can directly work on the source files.
1060 That is to say, unless a later phase changes the working directory to something
1063 We modify the list of @code{%standard-phases} of the build system with the
1064 @code{modify-phases} macro as per the list of specified modifications, which may have
1065 the following forms:
1069 @code{(add-before PHASE NEW-PHASE PROCEDURE)}: Run @code{PROCEDURE} named @code{NEW-PHASE} before @code{PHASE}.
1071 @code{(add-after PHASE NEW-PHASE PROCEDURE)}: Same, but afterwards.
1073 @code{(replace PHASE PROCEDURE)}.
1075 @code{(delete PHASE)}.
1078 The @code{PROCEDURE} supports the keyword arguments @code{inputs} and @code{outputs}. Each
1079 input (whether @emph{native}, @emph{propagated} or not) and output directory is referenced
1080 by their name in those variables. Thus @code{(assoc-ref outputs "out")} is the store
1081 directory of the main output of the package. A phase procedure may look like
1085 (lambda* (#:key inputs outputs #:allow-other-keys)
1086 (let (((bash-directory (assoc-ref inputs "bash"))
1087 (output-directory (assoc-ref outputs "out"))
1088 (doc-directory (assoc-ref outputs "doc"))
1093 The procedure must return @code{#t} on success. It's brittle to rely on the return
1094 value of the last expression used to tweak the phase because there is no
1095 guarantee it would be a @code{#t}. Hence the trailing @code{#t} to ensure the right value
1096 is returned on success.
1098 @subsubsection Code staging
1100 The astute reader may have noticed the quasi-quote and comma syntax in the
1101 argument field. Indeed, the build code in the package declaration should not be
1102 evaluated on the client side, but only when passed to the Guix daemon. This
1103 mechanism of passing code around two running processes is called @uref{https://arxiv.org/abs/1709.00833, code staging}.
1105 @subsubsection Utility functions
1107 When customizing @code{phases}, we often need to write code that mimics the
1108 equivalent system invocations (@code{make}, @code{mkdir}, @code{cp}, etc.)@: commonly used during
1109 regular ``Unix-style'' installations.
1111 Some like @code{chmod} are native to Guile.
1112 @xref{,,, guile, Guile reference manual} for a complete list.
1114 Guix provides additional helper functions which prove especially handy in the
1115 context of package management.
1117 Some of those functions can be found in
1118 @samp{$GUIX_CHECKOUT/guix/guix/build/utils.scm}. Most of them mirror the behaviour
1119 of the traditional Unix system commands:
1123 Like the @samp{which} system command.
1125 Akin to the @samp{find} system command.
1127 Like @samp{mkdir -p}, which creates all parents as needed.
1129 Similar to @samp{install} when installing a file to a (possibly
1130 non-existing) directory. Guile has @code{copy-file} which works
1132 @item copy-recursively
1134 @item delete-file-recursively
1137 Run an executable. This should be used instead of @code{system*}.
1138 @item with-directory-excursion
1139 Run the body in a different working directory,
1140 then restore the previous working directory.
1142 A ``@command{sed}-like'' function.
1145 @subsubsection Module prefix
1147 The license in our last example needs a prefix: this is because of how the
1148 @code{license} module was imported in the package, as @code{#:use-module ((guix licenses)
1149 #:prefix license:)}. The Guile module import mechanism
1150 (@pxref{Using Guile Modules,,, guile, Guile reference manual})
1151 gives the user full control over namespacing: this is needed to avoid
1152 clashes between, say, the
1153 @samp{zlib} variable from @samp{licenses.scm} (a @emph{license} value) and the @samp{zlib} variable
1154 from @samp{compression.scm} (a @emph{package} value).
1156 @node Other build systems
1157 @subsection Other build systems
1159 What we've seen so far covers the majority of packages using a build system
1160 other than the @code{trivial-build-system}. The latter does not automate anything
1161 and leaves you to build everything manually. This can be more demanding and we
1162 won't cover it here for now, but thankfully it is rarely necessary to fall back
1165 For the other build systems, such as ASDF, Emacs, Perl, Ruby and many more, the
1166 process is very similar to the GNU build system except for a few specialized
1169 @xref{Build Systems,,, guix, GNU Guix Reference Manual}, for more
1170 information on build systems, or check the source code in the
1171 @samp{$GUIX_CHECKOUT/guix/build} and
1172 @samp{$GUIX_CHECKOUT/guix/build-system} directories.
1174 @node Programmable and automated package definition
1175 @subsection Programmable and automated package definition
1177 We can't repeat it enough: having a full-fledged programming language at hand
1178 empowers us in ways that reach far beyond traditional package management.
1180 Let's illustrate this with some awesome features of Guix!
1182 @node Recursive importers
1183 @subsubsection Recursive importers
1185 You might find some build systems good enough that there is little to do at all
1186 to write a package, to the point that it becomes repetitive and tedious after a
1187 while. A @emph{raison d'être} of computers is to replace human beings at those
1188 boring tasks. So let's tell Guix to do this for us and create the package
1189 definition of an R package from CRAN (the output is trimmed for conciseness):
1192 $ guix import cran --recursive walrus
1194 (define-public r-mc2d
1198 (define-public r-jmvcore
1202 (define-public r-wrs2
1206 (define-public r-walrus
1213 (uri (cran-uri "walrus" version))
1216 "1nk2glcvy4hyksl5ipq2mz8jy4fss90hx6cq98m3w96kzjni6jjj"))))
1217 (build-system r-build-system)
1219 `(("r-ggplot2" ,r-ggplot2)
1220 ("r-jmvcore" ,r-jmvcore)
1222 ("r-wrs2" ,r-wrs2)))
1223 (home-page "https://github.com/jamovi/walrus")
1224 (synopsis "Robust Statistical Methods")
1226 "This package provides a toolbox of common robust statistical
1227 tests, including robust descriptives, robust t-tests, and robust ANOVA.
1228 It is also available as a module for 'jamovi' (see
1229 <https://www.jamovi.org> for more information). Walrus is based on the
1230 WRS2 package by Patrick Mair, which is in turn based on the scripts and
1231 work of Rand Wilcox. These analyses are described in depth in the book
1232 'Introduction to Robust Estimation & Hypothesis Testing'.")
1236 The recursive importer won't import packages for which Guix already has package
1237 definitions, except for the very first.
1239 Not all applications can be packaged this way, only those relying on a select
1240 number of supported systems. Read about the full list of importers in
1241 the guix import section of the manual
1242 (@pxref{Invoking guix import,,, guix, GNU Guix Reference Manual}).
1244 @node Automatic update
1245 @subsubsection Automatic update
1247 Guix can be smart enough to check for updates on systems it knows. It can
1248 report outdated package definitions with
1251 $ guix refresh hello
1254 In most cases, updating a package to a newer version requires little more than
1255 changing the version number and the checksum. Guix can do that automatically as
1259 $ guix refresh hello --update
1263 @subsubsection Inheritance
1265 If you've started browsing the existing package definitions, you might have
1266 noticed that a significant number of them have a @code{inherit} field:
1269 (define-public adwaita-icon-theme
1270 (package (inherit gnome-icon-theme)
1271 (name "adwaita-icon-theme")
1275 (uri (string-append "mirror://gnome/sources/" name "/"
1276 (version-major+minor version) "/"
1277 name "-" version ".tar.xz"))
1280 "17fpahgh5dyckgz7rwqvzgnhx53cx9kr2xw0szprc6bnqy977fi8"))))
1282 `(("gtk-encode-symbolic-svg" ,gtk+ "bin")))))
1285 All unspecified fields are inherited from the parent package. This is very
1286 convenient to create alternative packages, for instance with different source,
1287 version or compilation options.
1290 @subsection Getting help
1292 Sadly, some applications can be tough to package. Sometimes they need a patch to
1293 work with the non-standard file system hierarchy enforced by the store.
1294 Sometimes the tests won't run properly. (They can be skipped but this is not
1295 recommended.) Other times the resulting package won't be reproducible.
1297 Should you be stuck, unable to figure out how to fix any sort of packaging
1298 issue, don't hesitate to ask the community for help.
1300 See the @uref{https://www.gnu.org/software/guix/contact/, Guix homepage} for information on the mailing lists, IRC, etc.
1303 @subsection Conclusion
1305 This tutorial was a showcase of the sophisticated package management that Guix
1306 boasts. At this point we have mostly restricted this introduction to the
1307 @code{gnu-build-system} which is a core abstraction layer on which more advanced
1308 abstractions are based.
1310 Where do we go from here? Next we ought to dissect the innards of the build
1311 system by removing all abstractions, using the @code{trivial-build-system}: this
1312 should give us a thorough understanding of the process before investigating some
1313 more advanced packaging techniques and edge cases.
1315 Other features worth exploring are the interactive editing and debugging
1316 capabilities of Guix provided by the Guile REPL@.
1318 Those fancy features are completely optional and can wait; now is a good time
1319 to take a well-deserved break. With what we've introduced here you should be
1320 well armed to package lots of programs. You can get started right away and
1321 hopefully we will see your contributions soon!
1324 @subsection References
1328 The @uref{https://www.gnu.org/software/guix/manual/en/html_node/Defining-Packages.html, package reference in the manual}
1331 @uref{https://gitlab.com/pjotrp/guix-notes/blob/master/HACKING.org, Pjotr’s hacking guide to GNU Guix}
1334 @uref{https://www.gnu.org/software/guix/guix-ghm-andreas-20130823.pdf, ``GNU Guix: Package without a scheme!''}, by Andreas Enge
1337 @c *********************************************************************
1338 @node System Configuration
1339 @chapter System Configuration
1341 Guix offers a flexible language for declaratively configuring your Guix
1342 System. This flexibility can at times be overwhelming. The purpose of this
1343 chapter is to demonstrate some advanced configuration concepts.
1345 @pxref{System Configuration,,, guix, GNU Guix Reference Manual} for a complete
1349 * Customizing the Kernel:: Creating and using a custom Linux kernel on Guix System.
1350 * Connecting to Wireguard VPN:: Connecting to a Wireguard VPN.
1351 * Customizing a Window Manager:: Handle customization of a Window manager on Guix System.
1352 * Running Guix on a Linode Server:: Running Guix on a Linode Server
1353 * Setting up a bind mount:: Setting up a bind mount in the file-systems definition.
1354 * Getting substitutes from Tor:: Configuring Guix daemon to get substitutes through Tor.
1357 @node Customizing the Kernel
1358 @section Customizing the Kernel
1360 Guix is, at its core, a source based distribution with substitutes
1361 (@pxref{Substitutes,,, guix, GNU Guix Reference Manual}), and as such building
1362 packages from their source code is an expected part of regular package
1363 installations and upgrades. Given this starting point, it makes sense that
1364 efforts are made to reduce the amount of time spent compiling packages, and
1365 recent changes and upgrades to the building and distribution of substitutes
1366 continues to be a topic of discussion within Guix.
1368 The kernel, while not requiring an overabundance of RAM to build, does take a
1369 rather long time on an average machine. The official kernel configuration, as
1370 is the case with many GNU/Linux distributions, errs on the side of
1371 inclusiveness, and this is really what causes the build to take such a long
1372 time when the kernel is built from source.
1374 The Linux kernel, however, can also just be described as a regular old
1375 package, and as such can be customized just like any other package. The
1376 procedure is a little bit different, although this is primarily due to the
1377 nature of how the package definition is written.
1379 The @code{linux-libre} kernel package definition is actually a procedure which
1383 (define* (make-linux-libre version hash supported-systems
1385 ;; A function that takes an arch and a variant.
1386 ;; See kernel-config for an example.
1388 (configuration-file #f)
1389 (defconfig "defconfig")
1390 (extra-options %default-extra-linux-options)
1391 (patches (list %boot-logo-patch)))
1395 The current @code{linux-libre} package is for the 5.1.x series, and is
1399 (define-public linux-libre
1400 (make-linux-libre %linux-libre-version
1402 '("x86_64-linux" "i686-linux" "armhf-linux" "aarch64-linux")
1403 #:patches %linux-libre-5.1-patches
1404 #:configuration-file kernel-config))
1407 Any keys which are not assigned values inherit their default value from the
1408 @code{make-linux-libre} definition. When comparing the two snippets above,
1409 you may notice that the code comment in the first doesn't actually refer to
1410 the @code{#:extra-version} keyword; it is actually for
1411 @code{#:configuration-file}. Because of this, it is not actually easy to
1412 include a custom kernel configuration from the definition, but don't worry,
1413 there are other ways to work with what we do have.
1415 There are two ways to create a kernel with a custom kernel configuration. The
1416 first is to provide a standard @file{.config} file during the build process by
1417 including an actual @file{.config} file as a native input to our custom
1418 kernel. The following is a snippet from the custom @code{'configure} phase of
1419 the @code{make-linux-libre} package definition:
1422 (let ((build (assoc-ref %standard-phases 'build))
1423 (config (assoc-ref (or native-inputs inputs) "kconfig")))
1425 ;; Use a custom kernel configuration file or a default
1426 ;; configuration file.
1429 (copy-file config ".config")
1430 (chmod ".config" #o666))
1431 (invoke "make" ,defconfig))
1434 Below is a sample kernel package. The @code{linux-libre} package is nothing
1435 special and can be inherited from and have its fields overridden like any
1439 (define-public linux-libre/E2140
1441 (inherit linux-libre)
1443 `(("kconfig" ,(local-file "E2140.config"))
1444 ,@@(alist-delete "kconfig"
1445 (package-native-inputs linux-libre))))))
1448 In the same directory as the file defining @code{linux-libre-E2140} is a file
1449 named @file{E2140.config}, which is an actual kernel configuration file. The
1450 @code{defconfig} keyword of @code{make-linux-libre} is left blank here, so the
1451 only kernel configuration in the package is the one which was included in the
1452 @code{native-inputs} field.
1454 The second way to create a custom kernel is to pass a new value to the
1455 @code{extra-options} keyword of the @code{make-linux-libre} procedure. The
1456 @code{extra-options} keyword works with another function defined right below
1460 (define %default-extra-linux-options
1461 `(;; https://lists.gnu.org/archive/html/guix-devel/2014-04/msg00039.html
1462 ("CONFIG_DEVPTS_MULTIPLE_INSTANCES" . #t)
1463 ;; Modules required for initrd:
1464 ("CONFIG_NET_9P" . m)
1465 ("CONFIG_NET_9P_VIRTIO" . m)
1466 ("CONFIG_VIRTIO_BLK" . m)
1467 ("CONFIG_VIRTIO_NET" . m)
1468 ("CONFIG_VIRTIO_PCI" . m)
1469 ("CONFIG_VIRTIO_BALLOON" . m)
1470 ("CONFIG_VIRTIO_MMIO" . m)
1471 ("CONFIG_FUSE_FS" . m)
1473 ("CONFIG_9P_FS" . m)))
1475 (define (config->string options)
1476 (string-join (map (match-lambda
1478 (string-append option "=m"))
1480 (string-append option "=y"))
1482 (string-append option "=n")))
1487 And in the custom configure script from the `make-linux-libre` package:
1490 ;; Appending works even when the option wasn't in the
1491 ;; file. The last one prevails if duplicated.
1492 (let ((port (open-file ".config" "a"))
1493 (extra-configuration ,(config->string extra-options)))
1494 (display extra-configuration port)
1497 (invoke "make" "oldconfig"))))
1500 So by not providing a configuration-file the @file{.config} starts blank, and
1501 then we write into it the collection of flags that we want. Here's another
1505 (define %macbook41-full-config
1506 (append %macbook41-config-options
1510 (@@@@ (gnu packages linux) %default-extra-linux-options)))
1512 (define-public linux-libre-macbook41
1513 ;; XXX: Access the internal 'make-linux-libre' procedure, which is
1514 ;; private and unexported, and is liable to change in the future.
1515 ((@@@@ (gnu packages linux) make-linux-libre) (@@@@ (gnu packages linux) %linux-libre-version)
1516 (@@@@ (gnu packages linux) %linux-libre-hash)
1518 #:extra-version "macbook41"
1519 #:patches (@@@@ (gnu packages linux) %linux-libre-5.1-patches)
1520 #:extra-options %macbook41-config-options))
1523 In the above example @code{%file-systems} is a collection of flags enabling
1524 different file system support, @code{%efi-support} enables EFI support and
1525 @code{%emulation} enables a x86_64-linux machine to act in 32-bit mode also.
1526 @code{%default-extra-linux-options} are the ones quoted above, which had to be
1527 added in since they were replaced in the @code{extra-options} keyword.
1529 This all sounds like it should be doable, but how does one even know which
1530 modules are required for a particular system? Two places that can be helpful
1531 in trying to answer this question is the
1532 @uref{https://wiki.gentoo.org/wiki/Handbook:AMD64/Installation/Kernel, Gentoo
1534 @uref{https://www.kernel.org/doc/html/latest/admin-guide/README.html?highlight=localmodconfig,
1535 documentation from the kernel itself}. From the kernel documentation, it
1536 seems that @code{make localmodconfig} is the command we want.
1538 In order to actually run @code{make localmodconfig} we first need to get and
1539 unpack the kernel source code:
1542 tar xf $(guix build linux-libre --source)
1545 Once inside the directory containing the source code run @code{touch .config}
1546 to create an initial, empty @file{.config} to start with. @code{make
1547 localmodconfig} works by seeing what you already have in @file{.config} and
1548 letting you know what you're missing. If the file is blank then you're
1549 missing everything. The next step is to run:
1552 guix environment linux-libre -- make localmodconfig
1555 and note the output. Do note that the @file{.config} file is still empty.
1556 The output generally contains two types of warnings. The first start with
1557 "WARNING" and can actually be ignored in our case. The second read:
1560 module pcspkr did not have configs CONFIG_INPUT_PCSPKR
1563 For each of these lines, copy the @code{CONFIG_XXXX_XXXX} portion into the
1564 @file{.config} in the directory, and append @code{=m}, so in the end it looks
1568 CONFIG_INPUT_PCSPKR=m
1572 After copying all the configuration options, run @code{make localmodconfig}
1573 again to make sure that you don't have any output starting with ``module''.
1574 After all of these machine specific modules there are a couple more left that
1575 are also needed. @code{CONFIG_MODULES} is necessary so that you can build and
1576 load modules separately and not have everything built into the kernel.
1577 @code{CONFIG_BLK_DEV_SD} is required for reading from hard drives. It is
1578 possible that there are other modules which you will need.
1580 This post does not aim to be a guide to configuring your own kernel however,
1581 so if you do decide to build a custom kernel you'll have to seek out other
1582 guides to create a kernel which is just right for your needs.
1584 The second way to setup the kernel configuration makes more use of Guix's
1585 features and allows you to share configuration segments between different
1586 kernels. For example, all machines using EFI to boot have a number of EFI
1587 configuration flags that they need. It is likely that all the kernels will
1588 share a list of file systems to support. By using variables it is easier to
1589 see at a glance what features are enabled and to make sure you don't have
1590 features in one kernel but missing in another.
1592 Left undiscussed however, is Guix's initrd and its customization. It is
1593 likely that you'll need to modify the initrd on a machine using a custom
1594 kernel, since certain modules which are expected to be built may not be
1595 available for inclusion into the initrd.
1597 @node Connecting to Wireguard VPN
1598 @section Connecting to Wireguard VPN
1600 To connect to a Wireguard VPN server you need the kernel module to be
1601 loaded in memory and a package providing networking tools that support
1602 it (e.g. @code{wireguard-tools} or @code{network-manager}).
1604 Here is a configuration example for Linux-Libre < 5.6, where the module
1605 is out of tree and need to be loaded manually---following revisions of
1606 the kernel have it built-in and so don't need such configuration:
1610 (use-service-modules desktop)
1611 (use-package-modules vpn)
1615 (services (cons (simple-service 'wireguard-module
1616 kernel-module-loader-service-type
1619 (packages (cons wireguard-tools %base-packages))
1620 (kernel-loadable-modules (list wireguard-linux-compat)))
1623 After reconfiguring and restarting your system you can either use
1624 Wireguard tools or NetworkManager to connect to a VPN server.
1626 @subsection Using Wireguard tools
1628 To test your Wireguard setup it is convenient to use @command{wg-quick}.
1629 Just give it a configuration file @command{wg-quick up ./wg0.conf}; or
1630 put that file in @file{/etc/wireguard} and run @command{wg-quick up wg0}
1634 Be warned that the author described this command as a: “[…] very quick
1635 and dirty bash script […]”.
1638 @subsection Using NetworkManager
1640 Thanks to NetworkManager support for Wireguard we can connect to our VPN
1641 using @command{nmcli} command. Up to this point this guide assumes that
1642 you're using Network Manager service provided by
1643 @code{%desktop-services}. Ortherwise you need to adjust your services
1644 list to load @code{network-manager-service-type} and reconfigure your
1647 To import your VPN configuration execute nmcli import command:
1650 # nmcli connection import type wireguard file wg0.conf
1651 Connection 'wg0' (edbee261-aa5a-42db-b032-6c7757c60fde) successfully added
1654 This will create a configuration file in
1655 @file{/etc/NetworkManager/wg0.nmconnection}. Next connect to the
1659 $ nmcli connection up wg0
1660 Connection successfully activated (D-Bus active path: /org/freedesktop/NetworkManager/ActiveConnection/6)
1663 By default NetworkManager will connect automatically on system boot. To
1664 change that behaviour you need to edit your config:
1667 # nmcli connection modify wg0 connection.autoconnect no
1670 For more specific information about NetworkManager and wireguard
1671 @uref{https://blogs.gnome.org/thaller/2019/03/15/wireguard-in-networkmanager/,see
1672 this post by thaller}.
1674 @node Customizing a Window Manager
1675 @section Customizing a Window Manager
1682 You could install StumpWM with a Guix system by adding
1683 @code{stumpwm} and optionally @code{`(,stumpwm "lib")}
1684 packages to a system configuration file, e.g.@: @file{/etc/config.scm}.
1686 An example configuration can look like this:
1690 (use-package-modules wm)
1694 (packages (append (list sbcl stumpwm `(,stumpwm "lib"))
1698 @cindex stumpwm fonts
1699 By default StumpWM uses X11 fonts, which could be small or pixelated on
1700 your system. You could fix this by installing StumpWM contrib Lisp
1701 module @code{sbcl-ttf-fonts}, adding it to Guix system packages:
1705 (use-package-modules fonts wm)
1709 (packages (append (list sbcl stumpwm `(,stumpwm "lib"))
1710 sbcl-ttf-fonts font-dejavu %base-packages)))
1713 Then you need to add the following code to a StumpWM configuration file
1714 @file{~/.stumpwm.d/init.lisp}:
1717 (require :ttf-fonts)
1718 (setf xft:*font-dirs* '("/run/current-system/profile/share/fonts/"))
1719 (setf clx-truetype:+font-cache-filename+ (concat (getenv "HOME") "/.fonts/font-cache.sexp"))
1721 (set-font (make-instance 'xft:font :family "DejaVu Sans Mono" :subfamily "Book" :size 11))
1725 @subsection Session lock
1728 Depending on your environment, locking the screen of your session might come built in
1729 or it might be something you have to set up yourself. If you use a desktop environment
1730 like GNOME or KDE, it's usually built in. If you use a plain window manager like
1731 StumpWM or EXWM, you might have to set it up yourself.
1736 If you use Xorg, you can use the utility
1737 @uref{https://www.mankier.com/1/xss-lock, xss-lock} to lock the screen of your session.
1738 xss-lock is triggered by DPMS which since Xorg 1.8 is auto-detected and enabled if
1739 ACPI is also enabled at kernel runtime.
1741 To use xss-lock, you can simple execute it and put it into the background before
1742 you start your window manager from e.g. your @file{~/.xsession}:
1749 In this example, xss-lock uses @code{slock} to do the actual locking of the screen when
1750 it determines it's appropriate, like when you suspend your device.
1752 For slock to be allowed to be a screen locker for the graphical session, it needs to
1753 be made setuid-root so it can authenticate users, and it needs a PAM service. This
1754 can be achieved by adding the following service to your @file{config.scm}:
1757 (screen-locker-service slock)
1760 If you manually lock your screen, e.g. by directly calling slock when you want to lock
1761 your screen but not suspend it, it's a good idea to notify xss-lock about this so no
1762 confusion occurs. This can be done by executing @code{xset s activate} immediately
1763 before you execute slock.
1765 @node Running Guix on a Linode Server
1766 @section Running Guix on a Linode Server
1767 @cindex linode, Linode
1769 To run Guix on a server hosted by @uref{https://www.linode.com, Linode},
1770 start with a recommended Debian server. We recommend using the default
1771 distro as a way to bootstrap Guix. Create your SSH keys.
1777 Be sure to add your SSH key for easy login to the remote server.
1778 This is trivially done via Linode's graphical interface for adding
1779 SSH keys. Go to your profile and click add SSH Key.
1780 Copy into it the output of:
1783 cat ~/.ssh/<username>_rsa.pub
1786 Power the Linode down. In the Linode's Disks/Configurations tab, resize
1787 the Debian disk to be smaller. 30 GB is recommended.
1789 In the Linode settings, "Add a disk", with the following:
1798 Set it to the remaining size
1801 On the "configuration" field that comes with the default image, press
1802 "..." and select "Edit", then on that menu add to @file{/dev/sdc} the "Guix"
1805 Now "Add a Configuration", with the following:
1811 Kernel:GRUB 2 (it's at the bottom! This step is @b{IMPORTANT!})
1814 Block device assignment:
1817 @file{/dev/sda}: Guix
1820 @file{/dev/sdb}: swap
1823 Root device: @file{/dev/sda}
1826 Turn off all the filesystem/boot helpers
1829 Now power it back up, picking the Debian configuration. Once it's
1830 booted up, ssh in your server via @code{ssh
1831 root@@@var{<your-server-IP-here>}}. (You can find your server IP address in
1832 your Linode Summary section.) Now you can run the "install guix from
1833 @pxref{Binary Installation,,, guix, GNU Guix}" steps:
1836 sudo apt-get install gpg
1837 wget https://sv.gnu.org/people/viewgpg.php?user_id=15145 -qO - | gpg --import -
1838 wget https://git.savannah.gnu.org/cgit/guix.git/plain/etc/guix-install.sh
1839 chmod +x guix-install.sh
1844 Now it's time to write out a config for the server. The key information
1845 is below. Save the resulting file as @file{guix-config.scm}.
1850 (use-service-modules networking
1852 (use-package-modules admin
1859 (host-name "my-server")
1860 (timezone "America/New_York")
1861 (locale "en_US.UTF-8")
1862 ;; This goofy code will generate the grub.cfg
1863 ;; without installing the grub bootloader on disk.
1864 (bootloader (bootloader-configuration
1867 (inherit grub-bootloader)
1868 (installer #~(const #t))))))
1869 (file-systems (cons (file-system
1873 %base-file-systems))
1876 (swap-devices (list "/dev/sdb"))
1879 (initrd-modules (cons "virtio_scsi" ; Needed to find the disk
1880 %base-initrd-modules))
1882 (users (cons (user-account
1885 ;; Adding the account to the "wheel" group
1886 ;; makes it a sudoer.
1887 (supplementary-groups '("wheel"))
1888 (home-directory "/home/janedoe"))
1889 %base-user-accounts))
1891 (packages (cons* nss-certs ;for HTTPS access
1896 (service dhcp-client-service-type)
1897 (service openssh-service-type
1898 (openssh-configuration
1899 (openssh openssh-sans-x)
1900 (password-authentication? #f)
1902 `(("janedoe" ,(local-file "janedoe_rsa.pub"))
1903 ("root" ,(local-file "janedoe_rsa.pub"))))))
1907 Replace the following fields in the above configuration:
1909 (host-name "my-server") ; replace with your server name
1910 ; if you chose a linode server outside the U.S., then
1911 ; use tzselect to find a correct timezone string
1912 (timezone "America/New_York") ; if needed replace timezone
1913 (name "janedoe") ; replace with your username
1914 ("janedoe" ,(local-file "janedoe_rsa.pub")) ; replace with your ssh key
1915 ("root" ,(local-file "janedoe_rsa.pub")) ; replace with your ssh key
1918 The last line in the above example lets you log into the server as root
1919 and set the initial root password. After you have done this, you may
1920 delete that line from your configuration and reconfigure to prevent root
1923 Save your ssh public key (eg: @file{~/.ssh/id_rsa.pub}) as
1924 @file{@var{<your-username-here>}_rsa.pub} and your
1925 @file{guix-config.scm} in the same directory. In a new terminal run
1929 sftp root@@<remote server ip address>
1930 put /home/<username>/ssh/id_rsa.pub .
1931 put /path/to/linode/guix-config.scm .
1934 In your first terminal, mount the guix drive:
1938 mount /dev/sdc /mnt/guix
1941 Due to the way we set things up above, we do not install GRUB
1942 completely. Instead we install only our grub configuration file. So we
1943 need to copy over some of the other GRUB stuff that is already there:
1946 mkdir -p /mnt/guix/boot/grub
1947 cp -r /boot/grub/* /mnt/guix/boot/grub/
1950 Now initialize the Guix installation:
1953 guix system init guix-config.scm /mnt/guix
1957 Now from the Linode console, select boot and select "Guix".
1959 Once it boots, you should be able to log in via SSH! (The server config
1960 will have changed though.) You may encounter an error like:
1963 $ ssh root@@<server ip address>
1964 @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
1965 @ WARNING: REMOTE HOST IDENTIFICATION HAS CHANGED! @
1966 @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@
1967 IT IS POSSIBLE THAT SOMEONE IS DOING SOMETHING NASTY!
1968 Someone could be eavesdropping on you right now (man-in-the-middle attack)!
1969 It is also possible that a host key has just been changed.
1970 The fingerprint for the ECDSA key sent by the remote host is
1971 SHA256:0B+wp33w57AnKQuHCvQP0+ZdKaqYrI/kyU7CfVbS7R4.
1972 Please contact your system administrator.
1973 Add correct host key in /home/joshua/.ssh/known_hosts to get rid of this message.
1974 Offending ECDSA key in /home/joshua/.ssh/known_hosts:3
1975 ECDSA host key for 198.58.98.76 has changed and you have requested strict checking.
1976 Host key verification failed.
1979 Either delete @file{~/.ssh/known_hosts} file, or delete the offending line
1980 starting with your server IP address.
1982 Be sure to set your password and root's password.
1985 ssh root@@<remote ip address>
1986 passwd ; for the root password
1987 passwd <username> ; for the user password
1990 You may not be able to run the above commands at this point. If you
1991 have issues remotely logging into your linode box via SSH, then you may
1992 still need to set your root and user password initially by clicking on
1993 the ``Launch Console'' option in your linode. Choose the ``Glish''
1994 instead of ``Weblish''. Now you should be able to ssh into the machine.
1996 Horray! At this point you can shut down the server, delete the
1997 Debian disk, and resize the Guix to the rest of the size.
2000 By the way, if you save it as a disk image right at this point, you'll
2001 have an easy time spinning up new Guix images! You may need to
2002 down-size the Guix image to 6144MB, to save it as an image. Then you
2003 can resize it again to the max size.
2005 @node Setting up a bind mount
2006 @section Setting up a bind mount
2008 To bind mount a file system, one must first set up some definitions
2009 before the @code{operating-system} section of the system definition. In
2010 this example we will bind mount a folder from a spinning disk drive to
2011 @file{/tmp}, to save wear and tear on the primary SSD, without
2012 dedicating an entire partition to be mounted as @file{/tmp}.
2014 First, the source drive that hosts the folder we wish to bind mount
2015 should be defined, so that the bind mount can depend on it.
2018 (define source-drive ;; "source-drive" can be named anything you want.
2020 (device (uuid "UUID goes here"))
2021 (mount-point "/path-to-spinning-disk-goes-here")
2022 (type "ext4"))) ;; Make sure to set this to the appropriate type for your drive.
2025 The source folder must also be defined, so that guix will know it's not
2026 a regular block device, but a folder.
2028 (define (%source-directory) "/path-to-spinning-disk-goes-here/tmp") ;; "source-directory" can be named any valid variable name.
2031 Finally, inside the @code{file-systems} definition, we must add the
2035 (file-systems (cons*
2037 ...<other drives omitted for clarity>...
2039 source-drive ;; Must match the name you gave the source drive in the earlier definition.
2042 (device (%source-directory)) ;; Make sure "source-directory" matches your earlier definition.
2043 (mount-point "/tmp")
2044 (type "none") ;; We are mounting a folder, not a partition, so this type needs to be "none"
2045 (flags '(bind-mount))
2046 (dependencies (list source-drive)) ;; Ensure "source-drive" matches what you've named the variable for the drive.
2049 ...<other drives omitted for clarity>...
2054 @node Getting substitutes from Tor
2055 @section Getting substitutes from Tor
2057 Guix daemon can use a HTTP proxy to get substitutes, here we are
2058 configuring it to get them via Tor.
2061 @emph{Not all} Guix daemon's traffic will go through Tor! Only
2062 HTTP/HTTPS will get proxied; FTP, Git protocol, SSH, etc connections
2063 will still go through the clearnet. Again, this configuration isn't
2064 foolproof some of your traffic won't get routed by Tor at all. Use it
2067 Also note that the procedure described here applies only to package
2068 substitution. When you update your guix distribution with
2069 @command{guix pull}, you still need to use @command{torsocks} if
2070 you want to route the connection to guix's git repository servers
2074 Guix's substitute server is available as a Onion service, if you want
2075 to use it to get your substitutes through Tor configure your system as
2080 (use-service-module base networking)
2086 (service tor-service-type
2088 (config-file (plain-file "tor-config"
2089 "HTTPTunnelPort 127.0.0.1:9250"))))
2090 (modify-services %base-services
2092 config => (guix-configuration
2094 ;; ci.guix.gnu.org's Onion service
2095 (substitute-urls "https://bp7o7ckwlewr4slm.onion")
2096 (http-proxy "http://localhost:9250")))))))
2099 This will keep a tor process running that provides a HTTP CONNECT tunnel
2100 which will be used by @command{guix-daemon}. The daemon can use other
2101 protocols than HTTP(S) to get remote resources, request using those
2102 protocols won't go through Tor since we are only setting a HTTP tunnel
2103 here. Note that @code{substitutes-urls} is using HTTPS and not HTTP or
2104 it won't work, that's a limitation of Tor's tunnel; you may want to use
2105 @command{privoxy} instead to avoid such limitations.
2107 If you don't want to always get substitutes through Tor but using it just
2108 some of the times, then skip the @code{guix-configuration}. When you
2109 want to get a substitute from the Tor tunnel run:
2112 sudo herd set-http-proxy guix-daemon http://localhost:9250
2113 guix build --substitute-urls=https://bp7o7ckwlewr4slm.onion …
2116 @c *********************************************************************
2117 @node Advanced package management
2118 @chapter Advanced package management
2120 Guix is a functional package manager that offers many features beyond
2121 what more traditional package managers can do. To the uninitiated,
2122 those features might not have obvious use cases at first. The purpose
2123 of this chapter is to demonstrate some advanced package management
2126 @pxref{Package Management,,, guix, GNU Guix Reference Manual} for a complete
2130 * Guix Profiles in Practice:: Strategies for multiple profiles and manifests.
2133 @node Guix Profiles in Practice
2134 @section Guix Profiles in Practice
2136 Guix provides a very useful feature that may be quite foreign to newcomers:
2137 @emph{profiles}. They are a way to group package installations together and all users
2138 on the same system are free to use as many profiles as they want.
2140 Whether you're a developer or not, you may find that multiple profiles bring you
2141 great power and flexibility. While they shift the paradigm somewhat compared to
2142 @emph{traditional package managers}, they are very convenient to use once you've
2143 understood how to set them up.
2145 If you are familiar with Python's @samp{virtualenv}, you can think of a profile as a
2146 kind of universal @samp{virtualenv} that can hold any kind of software whatsoever, not
2147 just Python software. Furthermore, profiles are self-sufficient: they capture
2148 all the runtime dependencies which guarantees that all programs within a profile
2149 will always work at any point in time.
2151 Multiple profiles have many benefits:
2155 Clean semantic separation of the various packages a user needs for different contexts.
2158 Multiple profiles can be made available into the environment either on login
2159 or within a dedicated shell.
2162 Profiles can be loaded on demand. For instance, the user can use multiple
2163 shells, each of them running different profiles.
2166 Isolation: Programs from one profile will not use programs from the other, and
2167 the user can even install different versions of the same programs to the two
2168 profiles without conflict.
2171 Deduplication: Profiles share dependencies that happens to be the exact same.
2172 This makes multiple profiles storage-efficient.
2175 Reproducible: when used with declarative manifests, a profile can be fully
2176 specified by the Guix commit that was active when it was set up. This means
2177 that the exact same profile can be
2178 @uref{https://guix.gnu.org/blog/2018/multi-dimensional-transactions-and-rollbacks-oh-my/,
2179 set up anywhere and anytime}, with just the commit information. See the
2180 section on @ref{Reproducible profiles}.
2183 Easier upgrades and maintenance: Multiple profiles make it easy to keep
2184 package listings at hand and make upgrades completely friction-less.
2187 Concretely, here follows some typical profiles:
2191 The dependencies of a project you are working on.
2194 Your favourite programming language libraries.
2197 Laptop-specific programs (like @samp{powertop}) that you don't need on a desktop.
2200 @TeX{}live (this one can be really useful when you need to install just one
2201 package for this one document you've just received over email).
2207 Let's dive in the set up!
2209 @node Basic setup with manifests
2210 @subsection Basic setup with manifests
2212 A Guix profile can be set up @emph{via} a so-called @emph{manifest specification} that looks like
2216 (specifications->manifest
2218 ;; Version 1.3 of package-2.
2220 ;; The "lib" output of package-3.
2226 @pxref{Invoking guix package,,, guix, GNU Guix Reference Manual}, for
2229 We can create a manifest specification per profile and install them this way:
2232 GUIX_EXTRA_PROFILES=$HOME/.guix-extra-profiles
2233 mkdir -p "$GUIX_EXTRA_PROFILES"/my-project # if it does not exist yet
2234 guix package --manifest=/path/to/guix-my-project-manifest.scm --profile="$GUIX_EXTRA_PROFILES"/my-project/my-project
2237 Here we set an arbitrary variable @samp{GUIX_EXTRA_PROFILES} to point to the directory
2238 where we will store our profiles in the rest of this article.
2240 Placing all your profiles in a single directory, with each profile getting its
2241 own sub-directory, is somewhat cleaner. This way, each sub-directory will
2242 contain all the symlinks for precisely one profile. Besides, ``looping over
2243 profiles'' becomes obvious from any programming language (e.g.@: a shell script) by
2244 simply looping over the sub-directories of @samp{$GUIX_EXTRA_PROFILES}.
2246 Note that it's also possible to loop over the output of
2249 guix package --list-profiles
2252 although you'll probably have to filter out @file{~/.config/guix/current}.
2254 To enable all profiles on login, add this to your @file{~/.bash_profile} (or similar):
2257 for i in $GUIX_EXTRA_PROFILES/*; do
2258 profile=$i/$(basename "$i")
2259 if [ -f "$profile"/etc/profile ]; then
2260 GUIX_PROFILE="$profile"
2261 . "$GUIX_PROFILE"/etc/profile
2267 Note to Guix System users: the above reflects how your default profile
2268 @file{~/.guix-profile} is activated from @file{/etc/profile}, that latter being loaded by
2269 @file{~/.bashrc} by default.
2271 You can obviously choose to only enable a subset of them:
2274 for i in "$GUIX_EXTRA_PROFILES"/my-project-1 "$GUIX_EXTRA_PROFILES"/my-project-2; do
2275 profile=$i/$(basename "$i")
2276 if [ -f "$profile"/etc/profile ]; then
2277 GUIX_PROFILE="$profile"
2278 . "$GUIX_PROFILE"/etc/profile
2284 When a profile is off, it's straightforward to enable it for an individual shell
2285 without "polluting" the rest of the user session:
2288 GUIX_PROFILE="path/to/my-project" ; . "$GUIX_PROFILE"/etc/profile
2291 The key to enabling a profile is to @emph{source} its @samp{etc/profile} file. This file
2292 contains shell code that exports the right environment variables necessary to
2293 activate the software contained in the profile. It is built automatically by
2294 Guix and meant to be sourced.
2295 It contains the same variables you would get if you ran:
2298 guix package --search-paths=prefix --profile=$my_profile"
2301 Once again, see (@pxref{Invoking guix package,,, guix, GNU Guix Reference Manual})
2302 for the command line options.
2304 To upgrade a profile, simply install the manifest again:
2307 guix package -m /path/to/guix-my-project-manifest.scm -p "$GUIX_EXTRA_PROFILES"/my-project/my-project
2310 To upgrade all profiles, it's easy enough to loop over them. For instance,
2311 assuming your manifest specifications are stored in
2312 @file{~/.guix-manifests/guix-$profile-manifest.scm}, with @samp{$profile} being the name
2313 of the profile (e.g.@: "project1"), you could do the following in Bourne shell:
2316 for profile in "$GUIX_EXTRA_PROFILES"/*; do
2317 guix package --profile="$profile" --manifest="$HOME/.guix-manifests/guix-$profile-manifest.scm"
2321 Each profile has its own generations:
2324 guix package -p "$GUIX_EXTRA_PROFILES"/my-project/my-project --list-generations
2327 You can roll-back to any generation of a given profile:
2330 guix package -p "$GUIX_EXTRA_PROFILES"/my-project/my-project --switch-generations=17
2333 Finally, if you want to switch to a profile without inheriting from the
2334 current environment, you can activate it from an empty shell:
2337 env -i $(which bash) --login --noprofile --norc
2338 . my-project/etc/profile
2341 @node Required packages
2342 @subsection Required packages
2344 Activating a profile essentially boils down to exporting a bunch of
2345 environmental variables. This is the role of the @samp{etc/profile} within the
2348 @emph{Note: Only the environmental variables of the packages that consume them will
2351 For instance, @samp{MANPATH} won't be set if there is no consumer application for man
2352 pages within the profile. So if you need to transparently access man pages once
2353 the profile is loaded, you've got two options:
2357 Either export the variable manually, e.g.
2359 export MANPATH=/path/to/profile$@{MANPATH:+:@}$MANPATH
2363 Or include @samp{man-db} to the profile manifest.
2366 The same is true for @samp{INFOPATH} (you can install @samp{info-reader}),
2367 @samp{PKG_CONFIG_PATH} (install @samp{pkg-config}), etc.
2369 @node Default profile
2370 @subsection Default profile
2372 What about the default profile that Guix keeps in @file{~/.guix-profile}?
2374 You can assign it the role you want. Typically you would install the manifest
2375 of the packages you want to use all the time.
2377 Alternatively, you could keep it ``manifest-less'' for throw-away packages
2378 that you would just use for a couple of days.
2379 This way makes it convenient to run
2382 guix install package-foo
2383 guix upgrade package-bar
2386 without having to specify the path to a profile.
2388 @node The benefits of manifests
2389 @subsection The benefits of manifests
2391 Manifests are a convenient way to keep your package lists around and, say,
2392 to synchronize them across multiple machines using a version control system.
2394 A common complaint about manifests is that they can be slow to install when they
2395 contain large number of packages. This is especially cumbersome when you just
2396 want get an upgrade for one package within a big manifest.
2398 This is one more reason to use multiple profiles, which happen to be just
2399 perfect to break down manifests into multiple sets of semantically connected
2400 packages. Using multiple, small profiles provides more flexibility and
2403 Manifests come with multiple benefits. In particular, they ease maintenance:
2407 When a profile is set up from a manifest, the manifest itself is
2408 self-sufficient to keep a ``package listing'' around and reinstall the profile
2409 later or on a different system. For ad-hoc profiles, we would need to
2410 generate a manifest specification manually and maintain the package versions
2411 for the packages that don't use the default version.
2414 @code{guix package --upgrade} always tries to update the packages that have
2415 propagated inputs, even if there is nothing to do. Guix manifests remove this
2419 When partially upgrading a profile, conflicts may arise (due to diverging
2420 dependencies between the updated and the non-updated packages) and they can be
2421 annoying to resolve manually. Manifests remove this problem altogether since
2422 all packages are always upgraded at once.
2425 As mentioned above, manifests allow for reproducible profiles, while the
2426 imperative @code{guix install}, @code{guix upgrade}, etc. do not, since they produce
2427 different profiles every time even when they hold the same packages. See
2428 @uref{https://issues.guix.gnu.org/issue/33285, the related discussion on the matter}.
2431 Manifest specifications are usable by other @samp{guix} commands. For example, you
2432 can run @code{guix weather -m manifest.scm} to see how many substitutes are
2433 available, which can help you decide whether you want to try upgrading today
2434 or wait a while. Another example: you can run @code{guix pack -m manifest.scm} to
2435 create a pack containing all the packages in the manifest (and their
2436 transitive references).
2439 Finally, manifests have a Scheme representation, the @samp{<manifest>} record type.
2440 They can be manipulated in Scheme and passed to the various Guix @uref{https://en.wikipedia.org/wiki/Api, APIs}.
2443 It's important to understand that while manifests can be used to declare
2444 profiles, they are not strictly equivalent: profiles have the side effect that
2445 they ``pin'' packages in the store, which prevents them from being
2446 garbage-collected (@pxref{Invoking guix gc,,, guix, GNU Guix Reference Manual})
2447 and ensures that they will still be available at any point in
2450 Let's take an example:
2454 We have an environment for hacking on a project for which there isn't a Guix
2455 package yet. We build the environment using a manifest, and then run @code{guix
2456 environment -m manifest.scm}. So far so good.
2459 Many weeks pass and we have run a couple of @code{guix pull} in the mean time.
2460 Maybe a dependency from our manifest has been updated; or we may have run
2461 @code{guix gc} and some packages needed by our manifest have been
2465 Eventually, we set to work on that project again, so we run @code{guix environment
2466 -m manifest.scm}. But now we have to wait for Guix to build and install
2470 Ideally, we could spare the rebuild time. And indeed we can, all we need is to
2471 install the manifest to a profile and use @code{GUIX_PROFILE=/the/profile;
2472 . "$GUIX_PROFILE"/etc/profile} as explained above: this guarantees that our
2473 hacking environment will be available at all times.
2475 @emph{Security warning:} While keeping old profiles around can be convenient, keep in
2476 mind that outdated packages may not have received the latest security fixes.
2478 @node Reproducible profiles
2479 @subsection Reproducible profiles
2481 To reproduce a profile bit-for-bit, we need two pieces of information:
2487 a Guix channel specification.
2490 Indeed, manifests alone might not be enough: different Guix versions (or
2491 different channels) can produce different outputs for a given manifest.
2493 You can output the Guix channel specification with @samp{guix describe
2495 Save this to a file, say @samp{channel-specs.scm}.
2497 On another computer, you can use the channel specification file and the manifest
2498 to reproduce the exact same profile:
2501 GUIX_EXTRA_PROFILES=$HOME/.guix-extra-profiles
2502 GUIX_EXTRA=$HOME/.guix-extra
2504 mkdir "$GUIX_EXTRA"/my-project
2505 guix pull --channels=channel-specs.scm --profile "$GUIX_EXTRA/my-project/guix"
2507 mkdir -p "$GUIX_EXTRA_PROFILES/my-project"
2508 "$GUIX_EXTRA"/my-project/guix/bin/guix package --manifest=/path/to/guix-my-project-manifest.scm --profile="$GUIX_EXTRA_PROFILES"/my-project/my-project
2511 It's safe to delete the Guix channel profile you've just installed with the
2512 channel specification, the project profile does not depend on it.
2514 @c *********************************************************************
2515 @node Environment management
2516 @chapter Environment management
2518 Guix provides multiple tools to manage environment. This chapter
2519 demonstrate such utilities.
2522 * Guix environment via direnv:: Setup Guix environment with direnv
2525 @node Guix environment via direnv
2526 @section Guix environment via direnv
2528 Guix provides a @samp{direnv} package, which could extend shell after
2529 directory change. This tool could be used to prepare a pure Guix
2532 The following example provides a shell function for @file{~/.direnvrc}
2533 file, which could be used from Guix Git repository in
2534 @file{~/src/guix/.envrc} file to setup a build environment similar to
2535 described in @pxref{Building from Git,,, guix, GNU Guix Reference
2538 Create a @file{~/.direnvrc} with a Bash code:
2541 # Thanks <https://github.com/direnv/direnv/issues/73#issuecomment-152284914>
2545 local alias_dir=$PWD/.direnv/aliases
2546 mkdir -p "$alias_dir"
2547 PATH_add "$alias_dir"
2548 local target="$alias_dir/$name"
2549 if declare -f "$name" >/dev/null; then
2550 echo "#!$SHELL" > "$target"
2551 declare -f "$name" >> "$target" 2>/dev/null
2552 # Notice that we add shell variables to the function trigger.
2553 echo "$name \$*" >> "$target"
2561 export GUIX_GITHUB_TOKEN="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
2563 # Unset 'GUIX_PACKAGE_PATH'.
2564 export GUIX_PACKAGE_PATH=""
2566 # Recreate a garbage collector root.
2567 gcroots="$HOME/.config/guix/gcroots"
2569 gcroot="$gcroots/guix"
2575 # Miscellaneous packages.
2576 PACKAGES_MAINTENANCE=(
2590 # Environment packages.
2591 PACKAGES=(help2man guile-sqlite3 guile-gcrypt)
2593 # Thanks <https://lists.gnu.org/archive/html/guix-devel/2016-09/msg00859.html>
2594 eval "$(guix environment --search-paths --root="$gcroot" --pure guix --ad-hoc $@{PACKAGES[@@]@} $@{PACKAGES_MAINTENANCE[@@]@} "$@@")"
2596 # Predefine configure flags.
2599 ./configure --localstatedir=/var --prefix=
2601 export_function configure
2603 # Run make and optionally build something.
2609 ./pre-inst-env guix build "$@@"
2612 export_function build
2614 # Predefine push Git command.
2617 git push --set-upstream origin
2619 export_function push
2621 clear # Clean up the screen.
2622 git-cal --author='Your Name' # Show contributions calendar.
2624 # Show commands help.
2626 build build a package or just a project if no argument provided
2627 configure run ./configure with predefined parameters
2628 push push to upstream Git repository
2633 Every project containing @file{.envrc} with a string @code{use guix}
2634 will have predefined environment variables and procedures.
2636 Run @command{direnv allow} to setup the environment for the first time.
2638 @c *********************************************************************
2639 @node Acknowledgments
2640 @chapter Acknowledgments
2642 Guix is based on the @uref{https://nixos.org/nix/, Nix package manager},
2643 which was designed and
2644 implemented by Eelco Dolstra, with contributions from other people (see
2645 the @file{nix/AUTHORS} file in Guix.) Nix pioneered functional package
2646 management, and promoted unprecedented features, such as transactional
2647 package upgrades and rollbacks, per-user profiles, and referentially
2648 transparent build processes. Without this work, Guix would not exist.
2650 The Nix-based software distributions, Nixpkgs and NixOS, have also been
2651 an inspiration for Guix.
2653 GNU@tie{}Guix itself is a collective work with contributions from a
2654 number of people. See the @file{AUTHORS} file in Guix for more
2655 information on these fine people. The @file{THANKS} file lists people
2656 who have helped by reporting bugs, taking care of the infrastructure,
2657 providing artwork and themes, making suggestions, and more---thank you!
2659 This document includes adapted sections from articles that have previously
2660 been published on the Guix blog at @uref{https://guix.gnu.org/blog}.
2663 @c *********************************************************************
2664 @node GNU Free Documentation License
2665 @appendix GNU Free Documentation License
2666 @cindex license, GNU Free Documentation License
2667 @include fdl-1.3.texi
2669 @c *********************************************************************
2671 @unnumbered Concept Index
2677 @c ispell-local-dictionary: "american";