GNU Guix

Guix packages are defined through functional Guile Scheme APIs specifically designed for package management.

Dependencies are tracked directly in this language through special values called "derivations" which are evaluated by the Guix daemon lazily.

Guix keeps track of these references automatically so that installed packages can be garbage collected when no other package depends on them - at the cost of greater storage requirements, all upgrades in Guix are guaranteed to be both atomic and can be rolled back.

The roll-back feature of Guix is inherited from the design of Nix and is rarely found in other operating systems, since it requires an unorthodox approach to how the system should function (see MicroOS).

The Guix package manager, like Nix, can however be used on many distributions like Debian and Parabola.{{Cite web|url=https://tracker.debian.org/pkg/guix|title = Guix - Debian Package Tracker}}{{Cite web|title=Parabola GNU/Linux-libre - Package Search|url=https://www.parabola.nu/packages/?q=guix|access-date=2021-09-14|website=www.parabola.nu}}

This also enables multiple users to safely install software on the same system without administrator privileges.

Compared to traditional package managers, Guix package stores can grow considerably bigger and therefore require more bandwidth; although compared to container solutions (like Docker) that are also commonly employed to solve dependency hell, Guix is leaner and conforms to practices like don't repeat yourself and single source of truth. If the user chooses to build everything from source, even larger storage space and bandwidth is required.

Inherited from the design of Nix, most of the content of the package manager is kept in a directory /gnu/store where only the Guix daemon has write-access. This is achieved via specialised bind mounts, where the Store as a file system is mounted read only, prohibiting interference even from the root user, while the Guix daemon remounts the Store as read/writable in its own private namespace. Guix talks with this daemon to build things or fetch substitutes which are all kept in the store. Users are discouraged from ever manually touching the store by re-mounting it as writable since this defeats the whole purpose of the store.

Guix - like Nix - has built-in garbage collection facilities to help prune dead store items and keep the live ones.{{cite web |title=Invoking guix gc |url=https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-gc.html#Invoking-guix-gc |website=gnu.org |access-date=16 May 2019}}

This is an example of a package definition for the hello-package:

(use-modules

(guix packages)

(guix download)

(guix build-system gnu)

(guix licenses))

(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+)))

It is written using Guile. The package recipes can easily be inspected (running e.g. guix edit hello) and changed in Guix, making the system transparent and very easy to modify.

Inherited from the design of Nix, all manipulation of store items is independent of each other, and the directories of the store begin with a base32-encoded hash of the source code of the derivation along with its inputs.

Guix package uses profiles generations, which are a collection of symlinks to specific store items together comprising what the user has installed into the profile. Every time a package is installed or removed, a new generation will be built.

E.g. the profile of a user who only installed GNU Hello contains links to the store item which holds the version of hello installed with the currently used guix.

E.g. on version c087a90e06d7b9451f802323e24deb1862a21e0f of guix, this corresponds to the following item: /gnu/store/md2plii4g5sk66wg9cgwc964l3xwhrm9-hello-2.10 (built from the recipe above).

In addition to symlinks, each profile guix builds also contains a union of all the info-manuals, man-pages, icons, fonts, etc. so that the user can browse documentation and have access to all the icons and fonts installed.

The default symlinks to profile generations are stored under /var/guix in the filesystem.

The user can create any number of profiles by invoking {{kbd|guix package -p PROFILE-NAME COMMAND}}. A new directory with the profile-name as well as profile-generation-symlinks will then be created in the current directory.

Guix package enables instantaneous roll-back to a previous profile generation via changing the symlink to an earlier profile generation.{{cite web |title=Invoking guix package |url=https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-package.html#Invoking-guix-package |website=gnu.org |access-date=16 May 2019}} Profiles are also stored in the store e.g. this item is a profile containing hello above: /gnu/store/b4wipjlsapvnijmbawl7sh76087vpl4n-profile (built and activated when running guix install hello).

Guix shell enables the user to easily enter an environment where all the necessary packages for development of software are present without clogging up the user's default profile with dependencies for multiple projects.{{cite web |title=Invoking guix shell |url=https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-shell.html |website=gnu.org |access-date=22 Nov 2023}}

E.g. running {{kbd|guix shell --development hello}} enters a throw-away environment where everything needed to compile hello on guix is present (gcc, guile, etc.).

Without the {{kbd|--development}} flag, only the package hello would be installed and not its build-dependencies. This supplants the {{kbd|guix environment}} command, which installs the dependencies of a package by default, as it was considered more intuitive for the command to install the specified packages by default and only install development dependencies with a flag.{{cite web |title=From 'guix environment' to 'guix shell' |url=https://guix.gnu.org/blog/2021/from-guix-environment-to-guix-shell/ |website=gnu.org |access-date=22 Nov 2023}}

If you want a persistent gc-rooted environment that is not garbage collected on the next run of guix gc you can create a root:

E.g. running {{kbd|1=guix shell --root=hello-root --development hello}} enters an environment where everything needed to compile guix is present (gcc, guile, etc.) and registered as a root in the current directory (by symlinking to the items in the store).

Guix pack enables the user to bundle together store items and output them as either a docker binary image, a relocatable tarball, a Debian package file, a RPM package file, an AppImage or a squashfs binary.{{cite web |title=Invoking guix pack |url=https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-pack.html#Invoking-guix-pack |website=gnu.org |access-date=3 September 2024}}{{cite web | title=news: Add entry for guix pack's AppImage format | website=Savannah Git Server | date=2024-11-07 | url=https://git.savannah.gnu.org/cgit/guix.git/commit/etc/news.scm?id=8d6389b866d91a72569ecf50ddf313c17430d34b | access-date=2024-11-30}}{{cite web | title=news: Add entry for the new 'rpm' guix pack format. | website=Savannah Git Server | date=2023-02-17 | url=https://git.savannah.gnu.org/cgit/guix.git/commit/etc/news.scm?id=cc0cdf51f71c5455d781cd25842587731a83e414 | access-date=2024-11-30}}

Guix graph enables the user to view different graphs of the packages and their dependencies.{{cite web |title=Invoking guix graph |url=https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-graph.html#Invoking-guix-graph |website=gnu.org |access-date=16 May 2019}}

Guix allows you to specify additional channels for package definitions.{{cite web | title=Specifying Additional Channels (GNU Guix Reference Manual) | website=GNU Guix | url=https://guix.gnu.org/manual/en/html_node/Specifying-Additional-Channels.html | access-date=2024-11-23}}

This feature can also be used to install non-free software and firmware that cannot be packaged in the main project.{{cite web | title=Nonguix / nonguix · GitLab | website=GitLab | date=2024-11-23 | url=https://gitlab.com/nonguix/nonguix | access-date=2024-11-23}}{{cite web | title=Software Freedom (GNU Guix Reference Manual) | website=GNU Guix | url=https://guix.gnu.org/manual/en/html_node/Software-Freedom.html | access-date=2024-11-23}}

{{Infobox OS

| name = GNU Guix System

| logo = Guix logo.svg

| logo caption =

| logo size = 100px

| logo alt =

| screenshot = Guixsd-xfce-icecat-emacs.png

| caption = GNU Guix System running Xfce, GNU IceCat and GNU Emacs

| screenshot_size =

| screenshot_alt =

| collapsible =

| version of =

| developer = GNU Project{{cite web|url=https://www.gnu.org/software/guix/about|title=About — GuixSD|work=gnu.org|access-date=March 16, 2017|archive-date=April 12, 2017|archive-url=https://web.archive.org/web/20170412151807/https://www.gnu.org/software/guix/about/|url-status=live}}{{cite web | url=https://www.gnu.org/gnu/gnu-linux-faq.html | title=GNU/Linux FAQ - GNU Project - Free Software Foundation | publisher=Free Software Foundation | access-date=2017-05-14 | archive-date=September 7, 2013 | archive-url=https://web.archive.org/web/20130907132420/http://www.gnu.org/gnu/gnu-linux-faq.html | url-status=live }}

| family = Linux (Unix-like)

| working state = Current{{cite web | url=http://guix.gnu.org/download/ | title=Download — GNU Guix | access-date=2019-11-03 | archive-date=August 1, 2020 | archive-url=https://web.archive.org/web/20200801030945/http://guix.gnu.org/download/ | url-status=live }}

| source model = Free software, FSDG

| released =

| discontinued =

| RTM date =

| GA date =

| latest release version = {{wikidata|property|preferred|references|edit|Q19597382|P348|P548=Q2804309}}

| latest release date = {{Start date and age|{{wikidata|qualifier|preferred|single|Q19597382|P348|P548=Q2804309|P577}}}}

| latest preview version = {{wikidata|property|preferred|references|edit|Q19597382|P348|P548=Q51930650}}

| latest preview date = {{Start date and age|{{wikidata|qualifier|preferred|single|Q19597382|P348|P548=Q51930650|P577}}}}

| marketing target = Desktop

| programmed in =

| language =

| update model =

| package manager = GNU Guix

| supported platforms = x86_64, i686, aarch64, armv7, powerpc64le

| kernel type = Monolithic: Linux-libre (operational)

Microkernel: GNU Hurd (under development)

| userland = GNU

| ui =

| license = GPL

| preceded by =

| succeeded by =

| website = {{URL|https://guix.gnu.org/}}

| support status =

| other articles =

}}

GNU Guix System or Guix System{{Cite web|title=About — GNU Guix|url=https://guix.gnu.org/en/about/|access-date=2021-12-11|website=guix.gnu.org}}{{Cite web |title=Free GNU/Linux distributions |url=https://www.gnu.org/distros/free-distros.html |website=www.gnu.org}} (previously known as GuixSD{{cite mailing list |title=What to call Guix? |publisher=gnu-system-discuss |date=2015-01-15 |url=http://lists.gnu.org/archive/html/gnu-system-discuss/2015-01/threads.html |access-date=August 3, 2020 |archive-date=August 7, 2020 |archive-url=https://web.archive.org/web/20200807015108/https://lists.gnu.org/archive/html/gnu-system-discuss/2015-01/threads.html |url-status=dead }}) is a rolling release, free and open source Linux distribution built around Guix, similar to how NixOS is built around Nix.{{cite web |title=List of Free GNU/Linux Distributions |url=https://www.gnu.org/distros/free-distros.html |url-status=live |archive-url=https://web.archive.org/web/20200706001125/http://www.gnu.org/distros/free-distros.html |archive-date=July 6, 2020 |access-date=February 3, 2015 |website=www.gnu.org}}{{cite web | url=https://www.phoronix.com/scan.php?page=news_item&px=MTIzNjY | title=Guix: A New Package Manager & GNU Distribution | publisher=Phoronix | access-date=February 3, 2015 | archive-date=February 2, 2015 | archive-url=https://web.archive.org/web/20150202160820/http://www.phoronix.com/scan.php?page=news_item&px=MTIzNjY | url-status=live }} It enables a declarative operating system configuration{{cite web |title=Using the Configuration System |url=https://www.gnu.org/software/guix/manual/html_node/Using-the-Configuration-System.html |url-status=live |archive-url=https://web.archive.org/web/20190429053100/http://www.gnu.org/software/guix/manual/html_node/Using-the-Configuration-System.html |archive-date=April 29, 2019 |access-date=27 April 2019 |website=www.gnu.org}} and allows system upgrades that the user can rollback.{{cite web |title=Package Management |url=https://www.gnu.org/software/guix/manual/html_node/Package-Management.html |url-status=live |archive-url=https://web.archive.org/web/20190521083050/http://www.gnu.org/software/guix/manual/html_node/Package-Management.html |archive-date=May 21, 2019 |access-date=27 April 2019 |website=www.gnu.org}} It uses the GNU Shepherd init system{{Cite web|title=Programming Interface (GNU Guix Reference Manual)|url=https://guix.gnu.org/manual/en/html_node/Programming-Interface.html|access-date=2020-08-03|website=guix.gnu.org|archive-date=August 7, 2020|archive-url=https://web.archive.org/web/20200807063705/https://guix.gnu.org/manual/en/html_node/Programming-Interface.html|url-status=live}}{{Cite web|title=Guix: A New Package Manager & GNU Distribution - Phoronix|url=https://www.phoronix.com/scan.php?page=news_item&px=MTIzNjY|access-date=2020-08-03|website=www.phoronix.com|archive-date=July 6, 2018|archive-url=https://web.archive.org/web/20180706190833/https://www.phoronix.com/scan.php?page=news_item&px=MTIzNjY|url-status=live}} and the Linux-libre kernel, with the support of the GNU Hurd kernel under development.{{cite mailing list |title=GNU Guix & GuixSD 0.12.0 released |publisher=guix-devel |date=2016-12-21 |url=http://lists.gnu.org/archive/html/guix-devel/2016-12/msg00857.html |access-date=August 3, 2020 |archive-date=August 1, 2020 |archive-url=https://web.archive.org/web/20200801040538/https://lists.gnu.org/archive/html/guix-devel/2016-12/msg00857.html |url-status=dead }} On February 3, 2015, the Free Software Foundation added the distribution to its list of endorsed free Linux distributions.{{cite web | url=http://www.fsf.org/news/fsf-adds-guix-system-distribution-to-list-of-endorsed-distributions | title=FSF adds GNU Guix System Distribution to list of endorsed distributions | publisher=Free Software Foundation | date=3 February 2015 | access-date=February 3, 2015 | archive-date=February 3, 2015 | archive-url=https://web.archive.org/web/20150203220723/http://www.fsf.org/news/fsf-adds-guix-system-distribution-to-list-of-endorsed-distributions | url-status=dead }}

The following CPU architectures are supported:{{cite web |url=https://guix.gnu.org/download/ |title=Download |website=gnu.org |access-date=12 January 2024 |archive-date=October 6, 2021 |archive-url=https://web.archive.org/web/20211006202843/https://guix.gnu.org/download/ |url-status=live }}

• IA-32
• x86-64
• ARMv7{{cite web|url=https://www.gnu.org/software/guix/blog/2017/porting-guixsd-to-armv7/|title=Porting GuixSD to ARMv7|author=Mathieu Othacehe|access-date=February 17, 2018|archive-date=December 25, 2017|archive-url=https://web.archive.org/web/20171225124534/https://www.gnu.org/software/guix/blog/2017/porting-guixsd-to-armv7/|url-status=live}}
• AArch64
• POWER9{{cite web |title=New Supported Platform: powerpc64le-linux |url=https://guix.gnu.org/en/blog/2021/new-supported-platform-powerpc64le-linux/ |date = April 12, 2021 |last1=Marusich |first1=Chris |last2=Le Bouter |first2=Léo |access-date=October 6, 2021 |archive-date=May 16, 2021 |archive-url=https://web.archive.org/web/20210516202248/https://guix.gnu.org/en/blog/2021/new-supported-platform-powerpc64le-linux/ |url-status=live }}
• RISC-V 64{{cite web | title=Supported Platforms (GNU Guix Reference Manual)| website=GNU Guix | url=https://guix.gnu.org/manual/en/html_node/Supported-Platforms.html| access-date=2024-10-23}}
• MIPS64

System services, which are defined in the Guile Scheme,{{cite web |title=guix.git |url=http://git.savannah.gnu.org/cgit/guix.git/tree/gnu/services |website=git.savannah.gnu.org |access-date=11 May 2019 |archive-date=May 11, 2019 |archive-url=https://web.archive.org/web/20190511160745/http://git.savannah.gnu.org/cgit/guix.git/tree/gnu/services |url-status=live }} enable the user to declaratively compose the configuration of daemons and background services and specify configurations. This enables the user, within a single configuration file or modularized configuration, to configure the whole operating system (e.g., to have a Tor proxy, an ssh server, and a webserver serving guix-web via nginx on a specific port at bootup). They can:{{cite mailing list |last1=Wurmus |first1=Ricardo |title=Re: Help with preparing to move from Arch Linux to Guix |url=https://lists.gnu.org/archive/html/help-guix/2019-05/msg00262.html |website=help-guix |access-date=11 May 2019 |archive-date=August 1, 2020 |archive-url=https://web.archive.org/web/20200801074755/https://lists.gnu.org/archive/html/help-guix/2019-05/msg00262.html |url-status=live }}

• generate files in the filesystem (needed by some applications e.g. files in /etc)
• run any code for setting up daemons
• create specific user and group accounts (e.g. a database user for PostgreSQL)

The GNU Guix System uses the GNU Daemon Shepherd, formerly known as "dmd" ("Daemon managing Daemons"), as its init system, which is developed in tandem with Guix and is written and configurable in Guile.{{cite web | url=https://lists.gnu.org/archive/html/guix-devel/2016-01/msg00274.html | title=guix-devel mailing lists | access-date=2016-11-05 | archive-date=September 19, 2019 | archive-url=https://web.archive.org/web/20190919005906/https://lists.gnu.org/archive/html/guix-devel/2016-01/msg00274.html | url-status=live }} It supplies user-space functionality asynchronously as services, which under Shepherd are generic functions and object data types which it uses to extend the base operating system in a defined way. In contrast to systemd, a userspace shepherd process runs as the user. Central to the Shepherd model of user space initialization is the concept of the extension, a form of composability whereby services are designed to be layered onto other services, augmenting them with more elaborate or specialized behaviours as desired.{{cite web | url=https://www.gnu.org/software/guix/manual/html_node/Service-Composition.html#Service-Composition | title=GNU Guix Reference Manual: Service Composition | publisher=GNU Project | access-date=2016-11-05 | archive-date=January 1, 2019 | archive-url=https://web.archive.org/web/20190101055440/https://www.gnu.org/software/guix/manual/html_node/Service-Composition.html#Service-Composition | url-status=live }} This expresses the instantiation-based dependency relationships found in many modern init systems,{{cite web | url=https://fedoramagazine.org/systemd-unit-dependencies-and-order/ | title=systemd: Unit Dependencies and Order | date=November 25, 2015 | publisher=Fedora Magazine | access-date=2016-11-05 | archive-date=August 1, 2020 | archive-url=https://web.archive.org/web/20200801020502/https://fedoramagazine.org/systemd-unit-dependencies-and-order/ | url-status=live }} making the system modular, but also allows services to interact variadically with other services in arbitrary ways, e.g. a service that extends two other services, requiring only one to be present, but readily extending the second one if it is later instantiated without the need for any further reconfiguration or setup.

Shepherd also provides virtual services which allow dynamic dispatch over a class of related service objects, such as all those which instantiate a mail transfer agent (MTA) for the system.{{cite web | url=https://www.gnu.org/software/shepherd/manual/html_node/Jump-Start.html#Jump-Start | title=The GNU Shepherd Manual: Jump Start | publisher=GNU Project | access-date=2016-11-05 | archive-date=August 1, 2020 | archive-url=https://web.archive.org/web/20200801025359/https://www.gnu.org/software/shepherd/manual/html_node/Jump-Start.html#Jump-Start | url-status=live }} A system governed via the Shepherd daemon can represent its user space as a directed acyclic graph, with the "system-service," which is responsible for early phases of boot and init, as its root, and all subsequently initialized services as extensions to system-service functionality, either directly or transitively over other services.{{cite web | url=https://www.gnu.org/software/guix/manual/html_node/Shepherd-Services.html#Shepherd-Services | title=GNU Guix Reference Manual: Shepherd Services | publisher=GNU Project | access-date=2016-11-05 | archive-date=January 1, 2019 | archive-url=https://web.archive.org/web/20190101055405/https://www.gnu.org/software/guix/manual/html_node/Shepherd-Services.html#Shepherd-Services | url-status=live }}

It is intended to be highly programmable by the system administrator using Guile, but it can also be used to manage per-user profiles of unprivileged daemons and services.{{cite web | url=https://www.gnu.org/software/shepherd/manual/html_node/Introduction.html#Introduction | title=The GNU Shepherd Manual | publisher=GNU Project | access-date=2016-11-05 | archive-date=August 1, 2020 | archive-url=https://web.archive.org/web/20200801034906/https://www.gnu.org/software/shepherd/manual/html_node/Introduction.html#Introduction | url-status=live }} Its services and configuration are stored uniformly as object-oriented Scheme code, and while a core set of services are provided with the basic GNU Guix System,{{cite web | url=https://www.gnu.org/software/guix/manual/html_node/Services.html#Services | title=GNU Guix Reference Manual: Services | publisher=GNU Project | access-date=2016-11-05 | archive-date=December 25, 2018 | archive-url=https://web.archive.org/web/20181225093221/https://www.gnu.org/software/guix/manual/html_node/Services.html#Services | url-status=live }} arbitrary new services can be flexibly declared, and through Guile's object system, GOOPS, existing services can be redefined at the user's discretion by asking the Shepherd to dynamically rewrite services in specified ways on instantiation.{{cite web | url=https://www.gnu.org/software/guix/manual/html_node/Service-Types-and-Services.html#Service-Types-and-Services | title=GNU Guix Reference Manual: Service Types and Services | publisher=GNU Project | access-date=2016-11-05 | archive-date=January 5, 2019 | archive-url=https://web.archive.org/web/20190105220243/https://www.gnu.org/software/guix/manual/html_node/Service-Types-and-Services.html#Service-Types-and-Services | url-status=live }}{{cite web | url=https://www.gnu.org/software/guix/manual/html_node/Using-the-Configuration-System.html#Using-the-Configuration-System | title=GNU Guix Reference Manual: Using the Configuration System | publisher=GNU Project | access-date=2016-11-05 | archive-date=April 29, 2019 | archive-url=https://web.archive.org/web/20190429053100/http://www.gnu.org/software/guix/manual/html_node/Using-the-Configuration-System.html#Using-the-Configuration-System | url-status=live }}

GNU Shepherd was originally designed to work with GNU Hurd, and was later adopted by GNU Guix System.{{cite web | url=https://www.gnu.org/software/shepherd/ | title=GNU Shepherd | publisher=GNU project | access-date=2016-02-12 | archive-date=February 12, 2016 | archive-url=https://web.archive.org/web/20160212224150/https://www.gnu.org/software/shepherd/ | url-status=live }}

Similar to the roll-back feature of Nix, if a system update leaves users with a broken system, users can easily roll back individual packages as well as the whole system state with a simple command:
guix package --roll-back{{cite web |title=Invoking guix system |url=https://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-system.html |url-status=live |archive-url=https://web.archive.org/web/20190526043643/http://www.gnu.org/software/guix/manual/en/html_node/Invoking-guix-system.html |archive-date=May 26, 2019 |access-date=27 April 2019 |website=www.gnu.org}}
This means that the kind of stable channel that is very common in other Linux distributions is no longer needed for users who are willing to report a bug and wait a few minutes, when trying to update via guix pull. This is accomplished by a combination of Guix's functional package manager, which treats each package and system configuration as an immutable and reproducible entity,{{cite arXiv |last1=Courtès |first1=Ludovic |title=Functional Package Management with Guix |date=2013 |page=2 |class=cs.PL |eprint=1305.4584 }} and the generation system which maintains a history of system configurations as "generations." These generations are stored as separate profiles, which allow you to roll back to any previous configuration,{{cite web |title=Multi-dimensional transactions and rollbacks, oh my! |url=https://guix.gnu.org/en/blog/2018/multi-dimensional-transactions-and-rollbacks-oh-my/ |website=guix.gnu.org}} and you can see these generations with
guix package --list-generations.

Jesse Smith from DistroWatch Weekly reviewed GNU Guix System 0.15.0 (at the time named GuixSD), and said, "GuixSD has a package manager that I like", but criticized the limited hardware support and its limited documentation.{{Cite journal|url=https://distrowatch.com/weekly.php?issue=20180827#guixsd|title=GNU Guix System Distribution 0.15.0 and ReactOS 0.4.9|last1=Smith|first1=Jesse|issue=778|website=distrowatch.com|access-date=2018-08-30|archive-date=July 30, 2019|archive-url=https://web.archive.org/web/20190730123927/https://distrowatch.com/weekly.php?issue=20180827#guixsd|url-status=live}} The documentation has since then been expanded and improved with videos{{Cite web|title=Videos|url=http://guix.gnu.org/videos/|access-date=2020-03-03|archive-date=August 1, 2020|archive-url=https://web.archive.org/web/20200801025330/http://guix.gnu.org/videos/|url-status=live}} and a cookbook{{Cite web|title=Cookbook|url=http://guix.gnu.org/cookbook/|access-date=2020-03-03|archive-date=August 1, 2020|archive-url=https://web.archive.org/web/20200801021809/http://guix.gnu.org/cookbook/|url-status=live}} in six languages with tutorials, how-to guides and examples.

One particular area where Guix can offer to the user improvements over traditional package managers is in the field of reproducible scientific workflows, mainly in High Performance Computing.{{Cite web |title=Guix-HPC — Reproducible software deployment for high-performance computing — Blog |url=https://hpc.guix.info/blog/ |access-date=2024-11-05 |website=hpc.guix.info |language=en}} In this way, Guix would offer a way to share a reproducible computational environment, i.e. Guix using a recipe for the particular scientific software/environment would provide all the information needed to uniquely describe the dependency tree to build and run that software.{{Cite journal |last1=Vallet |first1=Nicolas |last2=Michonneau |first2=David |last3=Tournier |first3=Simon |date=2022-10-04 |title=Toward practical transparent verifiable and long-term reproducible research using Guix |journal=Scientific Data |language=en |volume=9 |issue=1 |pages=597 |doi=10.1038/s41597-022-01720-9 |pmid=36195618 |issn=2052-4463|pmc=9532446 |bibcode=2022NatSD...9..597V }} This would not be easy to achieve, for example, in other mixed systems with several package managers for each programming language. However, this only provides a necessary but not sufficient condition for scientific workflows to be reproducible, as it is necessary to incorporate data collection and processing into the workflow, if this is added as part of the Guix recipe, it could satisfy the strict reproducibility requirements.

The project was started in June 2012 by Ludovic Courtès, one of the GNU Guile hackers.{{cite mailing list |last=Stallman |first=Richard |title=A GNU Distribution |publisher=gnu-system-discuss|date=2012-06-05 |url=http://lists.gnu.org/archive/html/gnu-system-discuss/2012-06/msg00003.html}}

The GNU Project announced in November 2012 the first release of GNU Guix, a functional package manager based on Nix that provides, among other things, Guile Scheme APIs.{{cite mailing list |last=Courtès |first=Ludovic |title=Introducing GNU Guix|publisher=gnu-system-discuss|date=2012-11-23 |url=http://lists.gnu.org/archive/html/gnu-system-discuss/2012-11/msg00000.html}}

On August 20, 2015, it was announced that Guix had been ported to GNU Hurd.{{cite mailing list|url=https://lists.gnu.org/archive/html/guix-devel/2015-08/msg00379.html|title=[GSoC update] Porting Guix to GNU/Hurd|date=August 20, 2015|access-date=August 20, 2015|first=Manolis|last=Ragkousis|publisher=guix-devel}}

The project has no fixed release schedule and has until now released approximately every 6 months.

There are plans for an upcoming 1.5.0 release since there has been a 20 month gap since the 1.4.0 release.{{cite web | url=https://lists.gnu.org/archive/html/guix-devel/2024-09/msg00018.html | title=1.5.0 release? }}

{{Portal|Free and open-source software}}

• Debian GNU/Hurd
• NixOS – A similar operating system, which inspired GNU Guix{{Cite web|url=https://www.gnu.org/software/guix/about/|title=About — GuixSD|website=www.gnu.org|language=en|access-date=2018-05-03}}
• Comparison of Linux distributions

{{clear}}

{{reflist}}

{{Sister project links |collapsible=collapsed |display=GNU Guix |wikt=no |b=no |commons=Category:GNU Guix |d=Q18968627 |m=no |mw=no |n=no |q=no |s=Functional Package Management with Guix |v=no}}

• {{official website}}
• {{DistroWatch|guixsd|NAME=GNU Guix System}}
• [https://www.gnu.org/software/guix/packages List of Guix packages]

{{GNU}}

{{Package management systems}}

{{Linux distributions}}

Guix

Category:Free package management systems

Category:Free software programmed in Lisp

Category:Functional programming

Category:GNU Project software

Category:Linux package management-related software

Category:Linux distributions without systemd

Category:Software using the GNU General Public License