My Year With GNU Guix

<2020-05-25>

I bought a Chromebook Pixel last year. Google's line of premium laptops were some of the best looking machines ever put on the market and I've coveted them since their launch in 2013. I knew when I had the means (and they were a bit cheaper) I would get one; though I had no intention of ever using it as a chromebook. I had bigger plans when it arrived and happily flipped it on its back to remove its safety screw because I'd abandoned the notion of being safe with this laptop. I wanted to do something dangerous. I wanted to install linux.

Before this beauty arrived, I spent a fair amount of time looking at potential distributions. There was Debian, but if I were going to put that on a laptop I might as well have installed Ubuntu like some basic bitch. I considered Arch, which has really good documentation and an active ricing community but I spend way too much time emacsturbating to set up i3-gaps and tune a desktop to match my latest anime crush. After some deliberation I settled on trying NixOS, as I had a positive experience replacing homebrew with nix on a Macbook Pro at work. But then I found an alternative that made my heart sing.

In May 2019 a Nix-a-like reached 1.0 status after many years in development, this Nix-a-like seemed to fix a lot of things I disliked about nix like the "language", its baroque UI, and its lacking documentation. Earlier I hinted at spending a fair amount of time pleasuring myself with emacs, an editor that is probably 98% of the reason anyone gives a shit about LISP in 2020, and since I wrote the first version of the scheme module for Doom Emacs I already had everything in place to use a fully-conniving scheme to configure this system. I was all pretty much all in for this new weird distro called Guix System (nee GuixSD).

The Live USB was ready and waiting when the chromebook arrived.

Life In The Upside Down

At this point in the story I found out the hard way that when the guix project said they only trade in free software they meant they only trade in free software. This is unlike the Debian project which keeps a selection of non-free software in non-free repositories. No, the Guix project eschews cold pragmatism for red hot idealism, something I find incredibly attractive but inconvenient, like a woman with a scarab for a head. However this meant out of the gate my chromebook's wifi did not work, and I lacked a usb ethernet adapter, which meant I could not download any of that good shit like an actual working linux distribution. Some searching online showed that I would have to compile my own kernel for use with Guix. That is all well and good but in practice I had to create a new installation medium with the non-free kernel, and the easiest way to create a new installation medium for guix is to use the the guix package manager. At the time I was migrating from MacOS so I did not have a linux machine to install the guix package manager on. Booting up a VM to create the guix system ISO felt like a lot of work at the time so I just kinda... didn't.

I gave up and used NixOS.

Ya Boy Failed

Two months passed and I could not shake the way Guix System made me feel when I thought about ti. Our first date was a disaster but surely we could make it work, after all I had been playing with the package manager some on my NixOS machine and written some packages, and all that did was make me want to try out the stuff that wasn't necessarily worth doing on a foreign distribution, like using guix services. Eventually I gave up and decided to try again. After my nix configurations were in version control, so what was the harm in wiping hard drive yet again and trying out guix.

By now, the Nonguix channel existed and packaged a kernel with all the blobs for anyone to use in an installation medium. It wouldn't be hard to get started. With that in mind I went through the installer only to realize much too late that my installation medium, despite being built on a non-free kernel, did not install the non-free linux kernel when running guix system init. I had to boot up the installation medium again to add nonguix to the installation ISO's channels.scm file. This way after a guix pull packages in the Nonguix repo would be available.

;; if you don't add this to ~/.config/guix/channels.scm in the live
;; usb you won't actually install a non-free kernel on your system.
(cons* (channel
        (name 'nonguix)
        (url "https://gitlab.com/Nonguix/nonguix.git"))
       %default-channels)

With that out of the way I finally had a running Guix System with XFCE installed but there was a problem: the clock would not display anything other than UTC. I rage quit and reinstalled NixOS for another week.

This Sorta Sucks

Like everyone else, when adding a new distro the first thing I wanted to do was add my favorite browser. Unfortunately my favorite browser isn't here, only its bizarre counterpart icecat to replace firefox and "ungoogled" chromium to replace chrome. Not only that, ungoogled chromium can't easily install extensions and icecat comes bloated with the free software equivalent of a yahoo search panel and some bloatware. It isn't fun, and icecat hat a lot of trouble with some javascript heavy sites like Discord (which, being proprietary will not packaged standalone). Nevertheless, I persisted.

During this run I packaged xf86-input-cmt, a port of the ChromeOS multitouch drivers for linux, which was fairly straightforward as far as packaging software with scheme goes. However, as this was my first linux machine, I easily became carried away with trying out new desktop environments and window managers. Because this is also my first real exposure to the linux desktop I have a lot more to say on this, but it is outside of this testimonial's scope. But for a quick TLDR; tiling window managers are a black hole.

;;; a partial package definition for the chromebook multitiouch drivers
;; I use lambdas to modify phase tasks that, if this were nix, would normally be
;; done using an embedded shell script.
(define-public xf86-input-cmt
   (package
     (name "xf86-input-cmt")
     ...
     (arguments
      `(#:tests? #f
        #:configure-flags
        (list (string-append "--with-sdkdir="
                             (assoc-ref %outputs "out")
                             "/include/xorg"))
        #:phases
        (modify-phases %standard-phases
          (add-after 'install 'set-configs
            (lambda _
              (mkdir-p (string-append
                (assoc-ref %outputs "out")
                "/share/X11/xorg.conf.d"))
              (for-each
               (lambda (conf)
                 (with-directory-excursion "xorg-conf"
                   (copy-file conf
                              (string-append
                               (assoc-ref %outputs "out")
                               "/share/X11/xorg.conf.d/"
                               conf))))
               '("20-touchscreen.conf"
                 "40-touchpad-cmt.conf"
                 "50-touchpad-cmt-samus.conf"))
              #t)))))
     ...
     (home-page "https://github.com/GalliumOS/xf86-input-cmt")
     (synopsis "ChromiumOS X11 input driver")
     (description "")
     (license (list license:non-copyleft "https://github.com/GalliumOS"))))

Why Did I Keep Coming Back?

I wish I could say that it was all sunshine and rainbows from there on out, but that wasn't the case. A problem I had with videos in the browser was annoying enough to make me hop onto Manjaro for a little while, which has a much better desktop experience out of the box than Ubuntu and no problem playing the videos I wanted in the browser (porn mostly). I used Manjaro for at least a couple of months during which I relocated from Alabama to Anatomically Correct Alabama (New Mexico, seriously look at the two states on a map) and did not have the time to futz around as much as I wanted. However I missed GNU Guix System and had resolved in my heart that it was the distro for me. Everything else just kinda felt like shit when compared to Nix or Guix with regards to package management, setting up reproducible development environments, readying software for deployment, etc.

Despite my initial goal of just choosing a weird distro and learning it, I honestly became very fond of Guix, its community, and the goals of the project. If you haven't kept up with Pierre Neidhardt's site, particularly well thought out pieces like Guix, A Most Advanced Operating System and Why GNU Guix Matters, I encourage you to read them. That kind of positivity and depth stands in contrast with what I see from other posts on linux distributions which are usually from the perspective of distro hoppers like me who use a distro's package manager for a few days, rice their system and hit the forums ready to spit shit like their ass got sewed up. I also cannot stress enough how nice the scheme looks in a well written package or configuration file.

;; partial operating system configuration for a config.scm, guix's
;; equivalent of a configuration.nix
(operating-system
  (kernel linux)
  (locale "en_US.utf8")
  (host-name "samus")
  (timezone "America/Denver")
  (keyboard-layout (keyboard-layout "us" "altgr-intl" #:model "chromebook"))
  (bootloader (bootloader-configuration
                (bootloader grub-efi-bootloader)
                (timeout 1)
                (target "/boot/efi")))
  (firmware (append (list iwlwifi-firmware)
                    %base-firmware))
  ...
  (services
   (append
    (list (service gnome-desktop-service-type)
          (service openssh-service-type)
          (set-xorg-configuration
           (xorg-configuration
            (modules %samus/xorg-modules)
            (keyboard-layout keyboard-layout))))
    %desktop-services)))

The guix configuration just hits different for me, aesthetically. Scheme is a beautiful language, and in my eyes well-formed s-expressions resemble bone structure. When I look at the EDSL of guix I almost imagine I'm looking at the spine of my system, curving gently as I run my cursor down its back and twist it to into a working system that's all mine. This exists in contrast to, in my eyes, the slapdashery of emacs lisp or the implant scars of clojure, bursting open to revealing java(script) as I start to do anything even moderately complex. I really like writing s-expressions, and I really like using scheme as a language, for anything. It's part of the reason I chose haunt as the framework for this blog.

Maybe It's Love?

This is not really a story about why you should or should not use GNU Guix System. In fact, it's mostly a memoir of events and feelings that were experience in a year of trying the operating system on and off again. I cannot say I've done anything in a way that would suggest good lessons can be drawn from them.

Its valid to want something and be willing to go through the pains associated with having it, but sometimes the desire for something exceeds a person's capacity to approach it rationally or in a way that doesn't involve a lot of frustration, pain, and sometimes hurt. I'm fairly aware that my desire to use Guix System (rather than just guix, or their more mature cousins NixOS/Nix) is toxic. I've maybe used the system for a grand total of four months, but I can see myself using it or some derivative of it for the long run. I don't want to use any other distribution. To paraphrase something Christine Dodrill said after her recent positive flirtations with NixOS: I'm ruined, and It’s hard to go back.

---