Planet Guix

GoToSocial self-hosting tutorial

2026-05-17T00:00:00Z

Last year I went through a self-hosting spree during which I deployed some services (e.g. Nextcloud, Mattermost, and Prosody) to a bunch of VPSes, while documenting the process on this blog. This post is a follow-up on that series, detailing the deployment of GoToSocial, a lightweight ActivityPub (Fediverse) server written in Go.

Time travel without borders

2026-05-12T15:00:00Z

When offered the option to run other people’s code, a prime consideration is often ease of deployment. While much progress has been made in support of rapid deployment, the security implications of those quick deployments is often overlooked. In this post, we look at a new feature of guix time-machine and guix pull in support of one-line deployment commands : the ability to download channel files, but without compromising on security. Sharing code The normal workflow to share software and make it easily deployable with Guix goes like this: someone puts their packager hat on and…

Arguments parsing in Guile

2026-05-05T23:50:00Z

While Guile Scheme has a lot of hidden gems, like (ice-9 peg), parsing command line arguments is not one of its strengths in my opinion. Even if there are many powerful approaches to structured argument parsing, there is no API simple enough for me to know it by heart (as opposed for example to Python ArgumentParser).

GNU Mes and the expertise buildup

2026-05-05T21:00:00Z

Catching air in the middle of the deep-dive on Scheme bytecode interpreters.

A no-cost audio upgrade for my workstation

2026-05-05T11:38:00Z

How I did my part in saving the planet by getting an old but working audio interface up, running and mainlined in GNU Guix. Read the whole post here.

Guix at the French Reproducible Research Network conference

2026-05-04T14:00:00Z

Guix will be featured at the annual conference of the French Reproducible Research Network, 19–21 May 2026, Bordeaux, France.

Programming for the web with Guile Knots resource pools

2026-04-26T09:01:34Z

On the internet, anyone can make a request to your web service. Especially in this time of abusive web crawling linked to AI/LLM companies, it's essential to program in a defensive style and stay in control, even when faced with a volume of requests that can't be handled.

Using the substitute* procedure to alter Guix package source files

2026-04-18T19:19:00Z

Altering source files using the substitute procedure to search and replace text

Safsaf - A web framework for Guile

2026-04-14T09:09:16Z

Over the past week or two I've been working on a new web framework for Guile. This is based on the knowledge I've accumulated over the past 7 years working on things like the Guix Data Service, Guix Build Coordinator and Nar Herder, but also based on their code, as I've used Claude Code running Claude Opus 4.6 to build this (a large language model).

verteiler example project

2026-04-09T23:01:00Z

/ver-teil-en/ [german]: to distribute, to spread, to deal out

ZimaBoard 2 Setup

2026-04-03T11:29:22Z

I've got a new homeserver/NAS (Network Attached Storage), previously I was using some Raspberry Pis, but I've wanted for a while a low power board that has SATA ports for attaching hard drives and one that could run GNU Guix, and the ZimaBoard 2 looked like it might be a good option.

Announcing Guile Knots

2026-03-23T18:40:29Z

Guile Knots is a library providing higher-level patterns and building blocks for programming with Guile Fibers.

Install GUIX on Macbook 12

2026-03-20T10:01:00Z

I have an old Intel macbook 12 of begin 2016, one of the so-called "Retina Macbooks". It is an ideal couch device but far too slow to run modern OS-X, provided you wanted to run that to begin with.

A Sane Directory Structure for Software Projects

2026-03-15T07:46:00Z

I always spend too much time setting up a new project and thinking how to structure it. I decided to summuraize my experience, to enhance it with a small research and to write down my thoughts on the topic. So I can come back to it myself or reference in the discussion.

The 64-bit Hurd is Here!

2026-03-01T10:00:00Z

Fifteen months have passed since our last Guix/Hurd on a Thinkpad X60 post and a lot has happened with respect to the Hurd.

The 64-bit Hurd is Here!

2026-03-01T10:00:00Z

Fifteen months have passed since our last Guix/Hurd on a Thinkpad X60 post and a lot has happened with respect to the Hurd . And most of you will have guessed, unless you skipped the title of this post, the rumored x86_64 support has landed in Guix! Here is a not-so-short overview of our Hurd work over the past 1.5 years: The build daemon fails when invoking guix authenticate on the Hurd bug was fixed. This was our most pressing problem as it meant that we could not keep…

Hacklog: Diffing and Comparing Guix Derivations Using Breadth-first Search & Jaccard

2026-02-22T22:00:00Z

A cool thing about Guix (and probably functional package managers in general) is, that derivations form a directed acyclic graph, which means that all packages with their dependencies or system configurations can be represented as such. Another, even cooler, thing is, that Guix provides a graphing utility called `guix graph` which helps visualising these DAGs in Graphviz (if you ever wanted to frame a picture of your favorite package graph or play a game of "is this the dependency graph of a rust package or the visualization of a Mandelbrot set?" this should be the tool of your choice).

Forgejo, AGit, and Pull Request Templates

2026-02-21T00:00:00Z

I've raised a few PRs against the Guix Codeberg repository recently, and each time I've done so with Forgejo's AGit workflow. This workflow is pretty nice, and allows me to raise a PR entirely from within Emacs. To do that, I've been using this code in my Emacs config to add an extra option to the magit-push transient to use the AGit flow to push to the upstream branch:

Funding GNU Guix - Update at Guix Days 2026

2026-02-17T13:01:24Z

An update on the fundraising campaign to Sustain and Strengthen GNU Guix. Covers the fundraising done during the last few months of 2025 and into 2026. Goes into the proposed budget and activities for Guix Foundation during 2026. All the programmes are at a proposal stage, when this video was recorded, and may change depending on the decisions of the Foundation's membership council (SAC).

Result of Sustain and Strengthen Fundraising

2026-02-17T11:00:00Z

Results from Guix Fundraising We're on course to beat our fundraising target to sustain and strength Guix. We're bringing the fundraising campaign to an end, so let's cover how much we've raised and what it means for GNU Guix. After four months of fundraising we've raised €11,378 for the GNU Guix project. This means we've received money for 75% of our €15,000 annual goal. We also pre-registered tickets for Guix Days this year. Pjotr Prins and Manolis Ragkousis have done a stellar job organising it…

How I manage my Guix System configs

2026-02-15T13:41:00Z

I've been meaning to write up a post on how I manage my Guix System configurations for a while, because I've hit on a solution that feels kinda nice, inspired by how folks do things in NixOS.

Setting Up Cuirass Locally

2026-02-15T00:00:00Z

Recently I've been trying to get a PR merged with some fixes for Lua. I thought this would be a pretty straightforward thing to merge, but it turns out that modifying the Lua packages leads to 990 packages needing to be rebuilt. This is more than the 300 limit for a merge to master, so instead of merging my changes directly Andreas has kindly pushed them to a lua-team branch and queued it up behind go-team, gnome-team, and rust-team.

Guix days 2026 retrospective

2026-02-13T00:26:00Z

Last week, from Monday to Tuesday was Guix days! Guix days is an annual FOSDEM fringe event, where Guix hackers from Europe and abroad meet. This year was my second time going, and I was waiting for it all year! In this post, I’ll do a quick retrospective of what happened, and my thoughts on it. Thanks to Futurile for suggesting that I make this post :)

Ruby Development Using Guix

2026-02-08T00:00:00Z

Up until a few months ago, I was working on a Ruby on Rails monolith. In the four years that I worked on the project, we went through a few ways of building a local development environment:

Guix-HPC Activity Report, 2025

2026-02-06T14:00:00Z

Guix-HPC is a collaborative effort to bring reproducible software deployment to scientific workflows and high-performance computing (HPC). Guix-HPC builds upon the GNU Guix software deployment tools and aims to make them useful for HPC practitioners and scientists concerned with dependency graph control and customization and, uniquely, reproducible research.

Guix On MNT Pocket Reform: What's Still Missing?

2026-02-03T22:00:00Z

There was a session on running guix on weird computers during this years Guix Days, and five people brought their purple colored MNT Pocket Reform laptops with them, which proves two things in my book:

Installing And Running Guix System On (rk3588) MNT Pocket Reform

2026-01-26T22:00:00Z

I've been daily driving my MNT Pocket Reform for a year now, but only recently managed to set-up Guix System earlier this January, after a year of failed attempts. As of a few weeks ago I've been running:

GNU Guix 1.5.0 released

2026-01-23T14:00:00Z

We are pleased to announce the release of GNU Guix version 1.5.0! The release comes with ISO-9660 installation images, virtual machine images, and with tarballs to install the package manager on top of your GNU/Linux distro, either from source or from binaries—check out the download page . Guix users can update by running guix pull . It’s been 3 years since the previous release . That’s a lot of time, reflecting both the fact that, as a rolling release , users continuously get new features and update by running guix pull ; but it also shows a lack of…

Meet Guix at FOSDEM

2026-01-22T13:00:00Z

It’s that time of the year again: next week is FOSDEM time! As in previous years , many Guix people will be in Brussels. Right after FOSDEM, about sixty of us will gather on February 2–3 for the Guix Days! First things first: Guix presence at FOSDEM. On Saturday, January 31st : In Name resolution in package management systems — A reproducibility perspective , Gábor Boskovits will look will look at how several package managers refer to packages and how this affects reproducibility. Simon Tournier will…

Backup of S3 Objects Using rsnapshot

2026-01-17T22:04:01Z

I’ve been using rsnapshot to take backups of around 10 servers and laptops for well over 15 years, and it is a remarkably reliable tool that has proven itself many times. Rsnapshot uses rsync over SSH and maintains a temporal hard-link file pool. Once rsnapshot is configured and running, on the backup server, you get a hardlink farm with directories like this for the remote server:

Creating your own Guix substitute server

2025-12-21T16:30:00Z

I lately dedicated some time to setting up my own substitute server for Guix on a foreign distribution. This post is about that experience, after verifying that such a process is currently quite underdocumented. A substitute server is clearly a required step in order to cultivate a personal or unofficial/alternative channel for Guix, at least if one has more than one box (and possibly one physical location) to manage.

GNU Mes and the module system

2025-12-19T22:00:00Z

How does the GNU Mes module system work and why it is crucial for all the work.

With or without Guix: Deploying complex software stacks on major supercomputers

2025-12-12T14:30:00Z

How does Guix help in deploying complex HPC software stacks on supercomputers? A common misconception is that Guix helps if and only if it is installed on the target supercomputer. This would be a serious limitation since, to date, you may find Guix on a number of small- to medium-size clusters (“Tier-2”) but not yet on national and European supercomputers (“Tier-1” and “Tier-0”). While we boasted quite a few times about the use of guix pack to run benchmarks, one might wonder how much of it is applicable to more complex applications.

About computing environments for reproducible science

2025-12-09T13:00:00Z

A few weeks ago I gave a lecture for the Spatial Ecology course to introduce a handful of junior and not-so-junior researchers from various domains to the not-so-nice world of scientific computing environments.

Reproducible Guix Container Images

2025-12-06T22:22:41Z

Around a year ago I wrote about Guix Container Images for GitLab CI/CD and these images have served the community well. Besides continous use in CI/CD, these Guix container images are used to confirm reproducibility of the source tarball artifacts in the releases of Libtasn1 v4.20, InetUtils v2.6, Libidn2 v2.3.8, Libidn v1.43, SASL v2.2.2, Guile-GnuTLS v5.0.1, and OATH Toolkit v2.6.13. See how all those release announcements mention a Guix commit? That’s the essential supply-chain information about the Guix build environment that allows the artifacts to be re-created. To make sure this is repeatable, the release tarball artifacts are re-created from source code every week in the verify-reproducible-artifacts project, that I wrote about earlier. Guix’s time travelling feature make this sustainable to maintain, and hopefully will continue to be able to reproduce the exact same tarball artifacts for years to come.

A Planet for Guix

2025-12-05T12:00:00Z

I am pleased to announce the availability of Planet Guix , an Atom and RSS aggregator covering all things Guix. You can browse posts on the website or use your favourite feed reader to subscribe to the aggregate feed . Planet Guix already has subscriptions to 19 blogs from around the community; if you write about Guix (no matter how infrequently) and would like your blog to be included, or if you would like to suggest another blog I missed, please create a pull request against the repository in Codeberg — you'll see that the subscriptions are simply configured as association…

Guix on Trisquel & Ubuntu for Reproducible CI/CD Artifacts

2025-12-02T22:01:49Z

Last week I published Guix on Debian container images that prepared for today’s announcement of Guix on Trisquel/Ubuntu container images.

Container Images for Debian with Guix

2025-11-28T16:32:33Z

The debian-with-guix-container project build and publish container images of Debian GNU/Linux stable with GNU Guix installed.

Improved font rendering in Guix

2025-11-20T18:43:21Z

There is a neat trick to make fonts on Linux look thicker and smoother and sharper. Set the following variable in <code>/etc/environment</code>:

Connecting to a Cisco AnyConnect VPN on Guix System

2025-11-06T19:55:00Z

Yesterday, I got access to a virtual machine from my university for a school project. Great! The only catch: it was only accessible in the internal network via an obscure VPN protocol.

Update on the Guix Fundraising

2025-11-03T11:00:00Z

We're on our way It's been a month since we started the fundraising campaign to Sustain and Strengthen Guix. So far we've raised €6562 which is around 40% of our €15000 annual goal. If you'd like to support the project's fundraiser there's still time, pop over to the donate page now! DONATE NOW There have been a range of donations, both one-off and recurring. A few people have made large one-off donations, one of over €2150!There have been a couple between €500-€250 and a…

How to Set Up Guile Load Path

2025-10-30T12:00:00Z

Guile Load Path is a place (or more precisely places), where Guile looks for the source code. This is the first thing one needs to set correctly to work on a Guile Scheme project. It makes Guile aware both of your own modules and external dependencies. For more details refer to Load Paths page in Guile Reference Manual. This guide will focus on getting and setting the right values for it and discussing different approaches to do so.

Screenshot in Sway with GUIX

2025-10-25T12:19:00Z

A blog post documented an elegant way to configure screenshots in wayland using grim and grimshot. After moving my sway config to use the GUIX sway-service to generate the config file Iost my configured screenshot bindings.

Tiny Build Farm for Guix, part 2

2025-10-24T00:00:00Z

In our efforts to create a Tiny Build Farm for Guix, that is supposed to report on the status of the packages assigned to the science team, so far we have seen how to set up the required infrastructure. On a dedicated machine with Guix as its operating system, we have added several Shepherd services: the Guix Build Coordinator together with a build agent; and the web server part of the BFFE, which enables us to follow the activity of the builders. For performance reasons, we have renounced at installing an instance of the Guix Data Service, and opt instead for talking to the instance operated by the Guix project at https://data.guix.gnu.org/, which continually evaluates the Guix master branch and creates derivations for all packages in the distribution. The next step is to explore how to programmatically talk to the remote data server from a Guile script, how to extract derivations we are interested in, and how to submit them for building to our instance of the build coordinator.

I Have to Live in a Forest to Work on Open Source

2025-10-19T10:00:00Z

This fictional story begins more than 10 years ago. I was a student at technical university and was confused by how outdated some of the programming-related courses are. I was checking out a few first lections and usually skipping the rest of them (except a couple courses that were fun and uptodate). In my spare time I was tinkering on gentoo linux, cybersecurity and competitive programming (codeforces, ACM ICPC, etc). I wanted to start working ASAP, so that I could finally get to the most interesting part, but man, how wrong I was...

Fundraising campaign to sustain GNU Guix

2025-10-03T11:00:00Z

Today we're launching a fundraising campaign to sustain and strengthen GNU Guix. Guix is completely independent from any company or institution, we rely on the support of our community to fund the project. If you can, please help sustain Guix by making a donation . DONATE NOW Why we need your support Like many Free Software projects we need financial support because running a project is expensive. We incur costs for development infrastructure, facilitating developer collaboration and supporting the community around the project. As a package manager…

Vision

2025-10-02T12:00:00Z

Free Software for Correctness;
Correctness for Free Software.

Deploy Guix on DigitalOcean without cloud-init

2025-09-18T00:00:00Z

A cloud-init service for Guix is still a work in progress. Meanwhile, here's how you can deploy Guix on DigitalOcean right away.

Complex end-to-end tests using Guix G-expressions

2025-09-10T00:00:00Z

Complex end-to-end tests in development repositories involving packages written in several languages are a chore to describe and maintain. Often, the only recourse is to pull in pre-built binaries or haul around heavy Docker images. Could there be a better way? Could it be Guix (spoiler alert: yes!)?

Guix for geeks

2025-09-03T19:40:00Z

In the last few months, I have installed and upgraded my second preferred GNU/Linux system, GNU Guix, on multiple boxes. Regarding that system, I have already written a few introductory posts in the recent past. This is an update about my experiences as a user and developer. I still think Guix is a giant step forward in packaging and management, in comparison with Debian and other distributions, for elegance and inner coherence.

Privilege Escalation Vulnerability

2025-09-01T14:00:00Z

A security issue, CVE-2025-59378 , has been identified in guix-daemon , which allows for a local user to gain the privileges of any of the build users and subsequently use this to manipulate the output of any build. In the case of the rootless daemon, this also means gaining the privileges of guix-daemon . All systems are affected, whether or not guix-daemon is running with root privileges. You are strongly advised to upgrade your daemon now (see instructions below). The only requirements to exploit this are the ability to create and build an arbitrary derivation that has …

with-imported-modules and friends

2025-08-31T00:00:00Z

What is the ubiquitous with-imported-modules in G-expressions? Why do you need it when you already have use-modules?

Indent generated G-expression scripts

2025-08-28T00:00:00Z

Indent generated G-expression scripts with this trick to aid in debugging!

Tiny Build Farm for Guix, part 1

2025-08-27T00:00:00Z

One of the oft-cited reasons people give for not switching to Guix is that their favourite software is too outdated, and a look at Repology shows that they are not wrong. Now the number of active committers in the Guix project is amazingly small, and even counting all contributors I am impressed by what these few people actually achieve. Nevertheless I wondered how I could improve the situation at least a little bit for packages I am interested in, that is, for the science team; and the first step is to get an account of what actually builds and what does not. So I decided to set up my own little build farm, limited to the packages in the scope of the science team, using the same technology that powers the bordeaux build farm. I call it the Tiny Build Farm for Guix, or TBFG for short, and this post is the first one in (hopefully) a series of blog posts about the topic; at the time of starting this series, the TBFG does not actually exist yet, so wish me luck.

GNU Mes 0.27.1 released

2025-08-19T10:00:00Z

Mes 0.27.1 is a bug-fix release. It represents 53 commits by four people over one year. This release resurrects supports development builds with gcc-14 and adds support for using NYACC versions 0.99.0 through 2.02.2.

Wireguard VPN with Guix

2025-08-07T00:00:00Z

Recently I changed my ISP, and the new one uses Carrier-grade NAT, or CGNAT, by default. While this sounds fancy and professional, it is in fact even worse than conventional NAT: Not only do all my devices share the same IPv4, but I share one IPv4 with several other customers! Apparently I am only assigned a few out of the 65535 ports, and this assignment may change from day to day, which implies that I cannot connect from the outside to any of my home devices. However, I do have a separate IPv4 of my own for a virtual machine at Aquilenet, and it should be possible to use this as a trampoline to access my home through a virtual private network. We are already employing WireGuard for one of the Guix build farms, so it felt like a natural choice. Guix provides the wireguard-service-type, which is documented with all its options in the manual; but without an explanation of the general concepts behind the service it is a bit difficult to set up. The Guix Cookbook has an entry on WireGuard, but it is concerned with kernel modules and connecting to an existing WireGuard VPN, while my goal was to set one up in the first place. This turned out to be surprisingly easy.

Running Guix in Container Toolbox

2025-07-25T23:00:00Z

Using Guix with Container Toolbox on an atomic Fedora distrbution.

Privilege Escalation Vulnerabilities (CVE-2025-46415, CVE-2025-46416)

2025-06-24T14:00:00Z

Two security issues, known as CVE-2025-46415 and CVE-2025-46416 , have been identified in guix-daemon , which allow for a local user to gain the privileges of any of the build users and subsequently use this to manipulate the output of any build, as well as to subsequently gain the privileges of the daemon user. You are strongly advised to upgrade your daemon now (see instructions below), especially on multi-user systems. Both exploits require the ability to start a derivation build. CVE-2025-46415 requires the ability to create files in /tmp in the…

NeoMutt: filtering email with Sieve

2025-06-07T10:34:00Z

Using Mailutil's Sieve to filter email

Bonfire & Guix, a love story

2025-06-04T23:23:00Z

Bonfire is a new framework to build federated applications that just reached RC1. It is written in Elixir, a nice functional language, and allows communities to create custom flavored Fediverse applications, that can be tailored for their specific needs. I have been in touch with the core team and I'm trying to make the experience of running Bonfire on Guix as smooth as possible.

Understanding GNU Mes’ performance

2025-06-01T21:00:00Z

How fast is GNU Mes’ scheme interpreter really?

No JS, No BS Ethical Web Analytics

2025-05-31T12:00:00Z

I had two goals: to count AI crawlers DDoSing my nginx infrastructure and to see if anybody reads at least one of my three posts in the blog. To achieve both, I needed to gather data and transform it into meaningful insights, so basically I needed web analytics.

NeoMutt: Automating new email with Goimapnotify

2025-05-29T10:34:00Z

Using Goimapnotify for new email automation

NeoMutt: mirrored local IMAP with mbsync

2025-05-20T09:08:00Z

Multiple Accounts and colours in Neomutt

NeoMutt: Multiple accounts and themes

2025-05-19T09:57:00Z

Multiple accounts, colours and maildir in Neomutt

NeoMutt: using IMAP and SMTP

2025-05-18T10:45:00Z

Using IMAP in Neomutt and options for sending email using SMTP

NeoMutt: introduction to CLI email

2025-05-17T13:23:00Z

Introduction to using Neomutt. Emailing like it's 1995 in 2025!

A side of Guile: Regular expressions in Guile Scheme (Groups and escaping)

2025-05-11T14:22:00Z

Part 3 of an introduction to regular expressions in Guile Scheme: anchors, grouping and backslash escaping

A side of Guile: Regular expressions in Guile Scheme (Quantifiers)

2025-05-10T08:11:00Z

Part 2 of regular expressions in Guile Scheme: quantifiers, interval expressions and greedy matching

A side of Guile: Regular expressions in Guile Scheme

2025-05-09T14:23:00Z

Part 1 of an introduction to regular expressions in Guile Scheme: metacharacters and character sets

Declarative, transactional, cloud native OCI provisioning with Guix

2025-05-06T23:33:00Z

Many applications are packaged in OCI images but not in Guix. A good subset of them is written either in NodeJS, Go, Rust or languages that, as a general approach, encourage applications to have huge dependency graphs.

Building Debian in a GitLab Pipeline

2025-04-30T09:25:59Z

After thinking about multi-stage Debian rebuilds I wanted to implement the idea. Recall my illustration:

Verified Reproducible Tarballs

2025-04-17T19:24:46Z

Remember the XZ Utils backdoor? One factor that enabled the attack was poor auditing of the release tarballs for differences compared to the Git version controlled source code. This proved to be a useful place to distribute malicious data.

G-expressions: Makings of a Make-killer?

2025-04-14T00:00:00Z

Can Guix's G-expressions make for a superior Make-like build tool? Here's a proof-of-concept implementation imagining such a future.

Build daemon drops its privileges

2025-03-31T14:00:00Z

“Does it really need to run as root?” When talking to system administrators of large supercomputers about installing Guix and having its build daemon run as root, this question would quickly come up—and rightfully so. We’re happy to announce that guix-daemon can now run without root privileges by taking advantage of Linux’s unprivileged user namespaces, a feature now available even on some of the most conservative supercomputers.

On Binary Distribution Rebuilds

2025-03-31T08:21:24Z

I rebuilt (the top-50 popcon) Debian and Ubuntu packages, on amd64 and arm64, and compared the results a couple of months ago. Since then the Reproduce.Debian.net effort has been launched. Unlike my small experiment, that effort is a full-scale rebuild with more architectures. Their goal is to reproduce what is published in the Debian archive.

Self-Hosting Forgejo in Guix using OCI containers

2025-03-28T21:53:59Z

Giacomo Leidi's talk at Guix.Social covering how to run Docker and OCI containers in Guix: bringing together the easy distribution of Docker containers, and the capabilities of Guix's declarative configuration. All part of his Gocix project (https://github.com/fishinthecalculator/gocix) which provides ready made services for Prometheus, Bonfire, Grafana, Forgejo and others.

Reproducible Software Releases

2025-03-24T11:09:10Z

Around a year ago I discussed two concerns with software release archives (tarball artifacts) that could be improved to increase confidence in the supply-chain security of software releases. Repeating the goals for simplicity:

XMPP self-hosting tutorial

2025-02-23T00:00:00Z

In this post we'll see how to install and configure Prosody, an open-source XMPP server. We will be deploying Prosody on a Hetzner cloud instance, provisioned and configured with Guix and the powerful guix deploy command.

Guix-HPC Activity Report, 2024

2025-02-11T15:30:00Z

Guix, XIM, Emacs, Multi_key, Shft+SPC

2025-01-30T18:22:00Z

A bit out of order, but things tangle, a problem I’m having on my Guix machine with Emacs.

A Modern and Extensible IDE for Guile Scheme

2025-01-19T14:57:20Z

Andrew Tropin (https://trop.in) introduces Emacs-Arei a modern, extensible IDE for Guile Scheme. Using the Nrepl protocol foundation of Guile Ares-rs, it provides a highly interactive developer experience for programming Guile or Guix.

Join the Guix-Science community!

2025-01-16T14:00:00Z

Guix channels let communities develop and maintain their own package collection at their own pace. As users of Guix in high-performance computing (HPC) and computational sciences, we have been developing several such channels. Those channels live under the Guix-Science umbrella, which recently moved to Codeberg. Over the last couple of months, we’ve been using this migration as an opportunity to strengthen scientific channels, both socially—by welcoming more contributions—and technically—by setting up infrastructure to improve the contribution and maintenance workflows.

Nextcloud self-hosting tutorial

2025-01-15T00:00:00Z

Today I had to setup a Nextcloud instance on a cloud server. A completely scripted approach (e.g. via Ansible or OpenTofu) felt a bit over-engineered in my particular case, so I went for a semi-manual installation.

Brainstorming - managing a fleet of Guix machines with Goblins

2024-12-19T17:04:00Z

I've been noodling on the possibility of managing a bunch of Guix machines with Goblins for a little while now. Spent a little time at a local coffee shop today thinking about how this might work...

Guix Container Images for GitLab CI/CD

2024-12-18T18:43:38Z

I am using GitLab CI/CD pipelines for several upstream projects (libidn, libidn2, gsasl, inetutils, libtasn1, libntlm, …) and a long-time concern for these have been that there is too little testing on GNU Guix. Several attempts have been made, and earlier this year Ludo’ came really close to finish this. My earlier effort to idempotently rebuild Debian recently led me to think about re-bootstrapping Debian. Since Debian is a binary distribution, it re-use earlier binary packages when building new packages. The prospect of re-bootstrapping Debian in a reproducible way by rebuilding all of those packages going back to the beginning of time does not appeal to me. Instead, wouldn’t it be easier to build Debian trixie (or some future release of Debian) from Guix, by creating a small bootstrap sandbox that can start to build Debian packages, and then make sure that the particular Debian release can idempotently rebuild itself in a reproducible way? Then you will eventually end up with a reproducible and re-bootstrapped Debian, which pave the way for a trustworthy release of Trisquel. Fortunately, such an endeavour appears to offer many rabbit holes. Preparing Guix container images for use in GitLab pipelines is one that I jumped into in the last few days, and just came out of.

sourcehut as guix test farm

2024-12-17T16:57:05Z

It is possible to contribute to improving #guix as the need for new functionalities, packages, fixes or upgrades arise. This is one of the strongest points in open communities: the possibility to participate on the development and continuous improvement of the tool. Let’s see how it goes when it comes to guix.
Guix is a huge project which follows closely the #freesoftware paradigm, and collaboration works in two directions. You take advantage of other developers contributions to guix, while you participate yourself to improving guix repositories with your fixes, updates or new features, once they have been tested. In a first approach, from my own experience, one may create a personal local repository of package definitions, for a personal use. As a second step, it is possible to create a public guix channel, in parallel to contributing upstream.
Contributing your code to guix comes to sending #email with your patches attached, it’s that simple. Don't be intimidated by the details (this is used by lots of open communities, after all). Once your patches are submitted, a review of your code follows, see details. Some tools, like mumi, are helpful to that purpose.

Freedom vs security

2024-12-15T00:00:00Z

This is a painful post to write. It's about a choice one should never have to make, the choice between software freedom and security.

ci (sourcehut): alu

2024-12-13T12:38:24Z

Remote #ci is the way to go in #modernhw digital design testing. In this #ciseries, let’s see how to implement it with detail using sourcehut and a real world example.
Sourcehut is a lightweight #gitforge where I host my #git repositories. Not only it is based on a paradigm perfectly adapted to #modernhw, but also its builds service includes support for guix (x86_64) images. This means that we will be able to execute all of our testing online inside guix profiles, shells or natively on top of the bare-bones image.

ci (sourcehut): open-logic

2024-12-13T10:18:11Z

ci (gitlab/hub)

2024-12-11T12:50:04Z

Remote #ci is the way to go in #modernhw digital design testing. In this #ciseries, let’s see it in practice with some detail using two of the most popular forges out there.

ci (intro)

2024-12-08T21:19:43Z

How to seek, detect, be notified, analyze logs, understand and react to the different possible kind of issues one may encounter in a digital design is a vast topic of research, well beyond the scope of this modest post. But there are a couple of things we may state about here, though: automatizing issue detection is the way to go. Continuous integration (#ci) testing is a practice to adopt in #modernhw as a way to ensure that our design complies with its constraints. Let’s see this in more detail.

on testing

2024-12-06T09:32:14Z

Creating something new from scratch implies a certain ratio of unpredictable issues (loosely defined in the scope of this post: new errors, regressions, warnings, ... any unexpected behavior one may encounter). Most important, a digital design developer needs to define somehow what he considers to be a project issue, before even thinking about how to react to it. Luckily, in #modernhw a few usual tools are available to ease the process as a whole. Let’s overview some of them.
Here on the electronics digital design side of life, we have mainly three #freesoftware fine tools (among many others) to perform code checking to a large extent: osvvm, cocotb and vunit. They are all compatible with the ghdl compiler, and they are all available from my own #guix electronics channel (cocotb and vunit will hopefully get merged on guix upstream at some point). Each departs from the rest, adopting a different paradigm about how digital design testing should be understood: verification, cosimulation and unit testing are master keywords here.
They are all complementary, so you’ll be able to combine them to test your designs. However, you’ll need to be careful and check twice what you’re doing, as some of their features overlap (random treatment, for example). You’ve been warned.

guix crash course

2024-11-29T15:25:48Z

Guix reveals as a practical means of handling dependencies. However, the amount of information available to start using it may appear as a bit overwhelming for a beginner, letting the feeling of a tool reserved to a reduced community or experts. Far from that. Here you’ll find everything you need to get started with guix, with a light touch on using it for #modernhw.
We will concentrate in the use of #guix as an external package manager on top of a #linux distribution based on #systemd. We’ll let aside using and referring to #guixsystem as a full operating system by itself (which I never used anyway). This way, in the context of #modernhw, we may keep on using our favorite tools, environment and workflow. As an addition, we have everything that guix provides at our disposal, without affecting our local packages configuration: guix acts as an extra layer on top of our current OS, without any interference with it. You’ll have the possibility to install any guix software, remove it afterward or make use of the fancy features guix has to offer, without your host OS ever noticing what’s going on.
All what follows is roughly based on the guix reference manual and the guix cookbook, so refer to them for more on depth explanations. This article is strongly influenced by my personal experience as a daily driver, so next topics are necessarily biased towards my own needs.
There is much more to say about guix, but this is just an introductory crash course, right ?

Guix/Hurd on a Thinkpad X60

2024-11-24T18:00:00Z

A lot has happened with respect to the Hurd since our Childhurds and GNU/Hurd Substitutes post. As long as two years ago some of you have been asking for a progress update and although there have been rumours on a new blog post for over a year, we were kind of waiting for the rumoured x86_64 support.

Targeting the Cray/HPE Slingshot interconnect

2024-11-19T16:00:00Z

High-speed network interconnects are a key component of supercomputers. The challenge from a software packaging viewpoint is to provide an MPI stack able to get the performance out of that specialized networking hardware. As packagers, our approach has been to provide MPI packages that get the best performance of the underlying interconnect, be it Omni-Path, InfiniBand, or any other type of interconnect.

Guix-Jupyter 0.3.0 released!

2024-11-14T16:00:00Z

We are pleased to announce Guix-Jupyter 0.3.0, a long-overdue release of our Guix-powered Jupyter kernel for self-contained and reproducible notebooks.

A Org-based templating mechanism

2024-10-24T00:00:00Z

In a previous post I mentioned the way I use Emacs Org code blocks and the so-called Noweb syntax as a templating mechanism. The idea is to have a template version of a document containing a certain number of placeholders and a separate file to store the placeholders' values. The template and the data file are then fed into a build process that recombines things and produces the final document.

Visual structural editing for Guix (and Schemes in general)

2024-09-21T10:38:00Z

I've been noodling on structural editing for a while now. I'm fully bought into Lisps myself, but most of my friends and coworkers are skeptical, and I think a lot of their skepticism has to do (as usual) with all the parens. One of the points I make frequently is that with Lisp code being written as a nested data structure, the textual representation is just one of many possible representations. But it can be hard to get across what that means without concrete examples.

[Talk] Full Source Bootstrapping RISC-V on Guix

2024-09-18T21:00:00Z

People from Guix London gave me the chance to describe this process.

Full Source Bootstrapping RISC-V on Guix with Ekaitz Zarraga

2024-09-18T08:49:31Z

Ekaitz Zarraga talks about the mission to achieve a full source bootstrap of the RISC-V architecture on Guix Linux. He introduces RISC-V and what makes it different. Discusses the importance of a full source bootstrap for security and trust in computing. Then talks through the multi-year mission to make it a reality on Guix.

Playing with Vagrant, Virtualbox and Guix

2024-09-04T18:20:00Z

It is specifically convenient using Guix-the-system within a foreign distribution, such as Debian, for development and tests. The package management system can be used on top of the system, but I find it quite interesting to explore the potential of the Guix distribution in the context of virtualized environments. For personal use, that is also the ideal way to avoid breaking your own daily boxes every couple of days with daredevil approaches to personal computing.

The Guix system, take two

2024-09-02T20:00:00Z

Let's give a second look at Guix-the-system the main GNU Project distribution I dealt with in a previous post. This post is not specifically limited to the distribution, it is also of interest when using Guix in a foreign distribution, even if some configuration details change.

Guix patch reviews using Mumi by Jgart

2024-08-31T10:53:00Z

Recording of Jgart's Guix.social talk. How to use Mumi to review patches in Guix. Also discusses setting up email with RDE's home services in Guix.

Unprivileged container management on the Guix System

2024-08-23T04:20:00Z

Docker is known to have less than optimal security defaults, hence the hype for Podman. If you want to run rootless containers in your Guix System, it is sufficient to add the following to your operating-system configuration.

An initial dive into Guix

2024-08-18T19:00:00Z

In the last few days, I got familiar with Guix, which is both a modern package management system and the main GNU Project distribution for Linux and Hurd (the Guix system). As a package management system, it can be installed on most foreign distributions, including Debian and any other, as an alternative/additional packaging system.

Samba Adventures with Guix

2024-08-16T22:00:00Z

Samba or CIFS file sharing is a finicky area at best, but widely used, especially since it was heavily pushed by Microsoft in the Windows ecosystem, This makes it widely used in corporate and NAS environments and even for Linux file sharing.

Supporting academic conference artifact evaluation

2024-07-26T17:00:00Z

Having promoted Guix as one of the tools to support reproducible research workflows, we are happy that it is now officially presented as one way to produce and review software artifacts that accompany articles submitted to SuperComputing 2024 (SC24), the leading HPC conference. In this post we look at what this entails and reflect on the role of reproducible software deployment on conference artifact evaluation.

Guix package structure: build system phases and modify-phases

2024-07-23T11:15:00Z

Guix package structure: build phases and using modify-phases

A simplified home server setup, part 1

2024-07-17T00:00:00Z

In the first part of this post, last month, I described my attempt at using my Guix home server as a virtualisation environment. With a clever use of the Guile programming language (haha, really, by copying other people's code from the internet!) I was able to set up a small number of services, each one in its dedicated virtual machine for security-through-compartmentalisation.

Towards Idempotent Rebuilds?

2024-07-09T22:16:16Z

After rebuilding all added/modified packages in Trisquel, I have been circling around the elephant in the room: 99% of the binary packages in Trisquel comes from Ubuntu, which to a large extent are built from Debian source packages. Is it possible to rebuild the official binary packages identically? Does anyone make an effort to do so? Does anyone care about going through the differences between the official package and a rebuilt version? Reproducible-build.org‘s effort to track reproducibility bugs in Debian (and other systems) is amazing. However as far as I know, they do not confirm or deny that their rebuilds match the official packages. In fact, typically their rebuilds do not match the official packages, even when they say the package is reproducible, which had me surprised at first. To understand why that happens, compare the buildinfo file for the official coreutils 9.1-1 from Debian bookworm with the buildinfo file for reproducible-build.org’s build and you will see that the SHA256 checksum does not match, but still they declare it as a reproducible package. As far as I can tell of the situation, the purpose of their rebuilds are not to say anything about the official binary build, instead the purpose is to offer a QA service to maintainers by performing two builds of a package and declaring success if both builds match.

GNU Mes 0.27 released

2024-07-06T12:00:00Z

We are happy to announce the release of GNU Mes 0.27.

Milestone (End?) - Bootstrapping path discovered

2024-07-01T21:00:00Z

A RISC-V bootstrapping path path has been discovered. Now it’s time for the distros to catch up.

GNU Mes 0.26.2 released

2024-06-30T12:00:00Z

Mes 0.26.2 is a bug-fix release.

Guile, Guix and WASM, the future of the Web?

2024-06-28T13:20:59Z

David Thompson, CTO of Spritely Institute gives a talk about 'Getting Rich Slow with Guile and Guix' at the Guix.social online meet-up. David presents how he came to Guile via his love of Emacs, his developments in Guix and games, and his work at the Spritely Institute bringing Guile Hoot to the Web browser via WASM.

Workflows for Unix Password Store with Emacs and Shell

2024-06-25T00:00:00Z

On UNIX there is a well known tool to manage secrets called password-store or pass for short.

A simplified home server setup, part 0

2024-06-19T00:00:00Z

I've recently completed a major refactoring of my home server setup.

GNU Mes 0.26.1 released

2024-06-08T09:00:00Z

We are happy to announce the release of GNU Mes 0.26.1.

Terraform workflow using Guix and Emacs

2024-06-05T00:00:00Z

Terraform allows infrastructure to be defined to deploy applications and other solutions as code and supports a plethora of on-premise and cloud deployment targets.

Guix System Crafting talk by David Wilson

2024-05-31T13:46:22Z

David Wilson gives his tips, tricks and workflows for Guix system crafting. David is the creator of systemcrafters.net where he streams and creates content on Guix, Guile, Emacs and crafting the perfect Linux system.

All about Guix: chat with Ludovic Courtès project founder

2024-05-24T14:46:21Z

Recording (edited) of the Guix London Meetup chat with Ludovic Courtès. Ludo is a long-term #FreeSoftware hacker, interested in #lisp, #scheme and #guile. He is excited by the #nix deployment model, and created #guix.

TinyCC to GCC gap is slowly closing

2024-05-01T21:00:00Z

The sidetrack we took in the past started to give us some good news. Here there are some.

A side of Guile: Functions in Guile and Guix

2024-05-01T09:16:00Z

Introducing functions and modules in Guile Scheme and Guix

Compartmentalisation by means of virtualisation

2024-04-28T00:00:00Z

Now and then I find myself having to open a file or an application that I don't fully trust. A common technique to deal with this is to create a disposable environment (for example a so-called container or a virtual machine) where the file or application can be safely opened. Once used, the environment can be discarded.

Guix package structure: build-system overview and build arguments

2024-04-24T11:23:00Z

Guix package structure: build-system overview build arguments

Reproducible and minimal source-only tarballs

2024-04-13T16:44:27Z

With the release of Libntlm version 1.8 the release tarball can be reproduced on several distributions. We also publish a signed minimal source-only tarball, produced by git-archive which is the same format used by Savannah, Codeberg, GitLab, GitHub and others. Reproducibility of both tarballs are tested continuously for regressions on GitLab through a CI/CD pipeline. If that wasn’t enough to excite you, the Debian packages of Libntlm are now built from the reproducible minimal source-only tarball. The resulting binaries are reproducible on several architectures.

GCC 4.6.4 with RISC-V support in Guix

2024-04-01T21:00:00Z

We built GCC 4.6.4 with RISC-V support and C++ and all that and we made it run in Guix, finally.

So we’ve got sidetracked…

2024-03-29T22:00:00Z

We’ve got sidetracked, but it doesn’t really matter if we continue forward.

Guix package structure: inputs, native-inputs and propagated inputs

2024-03-29T19:19:00Z

Guix package structure: inputs, native-inputs and propagated-inputs

WireGuard connectivity issues

2024-03-29T00:00:00Z

tl;dr: If you use WireGuard, make sure NTP (or a similar time synchronisation mechanism) is set up on all VPN endpoints as the WireGuard protocol is sensitive to time-sync issues. Also, if you connect to a WireGuard server in an IPv6 network, make sure the server's firewall has sufficiently permissive ICMPv6 rules. Read on to find out why this is important.

GCC 4.6.4 with RISC-V support

2024-03-27T22:00:00Z

We built GCC 4.6.4 with RISC-V support and C++ and all that in a Debian machine, in a VisionFive board. Here is how.

Adventures on the quest for long-term reproducible deployment

2024-03-13T15:00:00Z

Rebuilding software five years later, how hard can it be? It can’t be that hard, especially when you pride yourself on having a tool that can travel in time and that does a good job at ensuring reproducible builds, right?

Guix package structure: overview and source/origin inputs

2024-03-04T13:10:00Z

Guix package structure: overview and source/origin inputs

Guix System On A Raspberry Pi 3b

2024-02-27T18:00:00Z

I've been running my trusty Raspberry Pi Single-Board Computer as a DNS, DHCP and Gitolite-Server at home since around 2016. It's been running on a minimal Raspbian and later on NixOS image, but I always wanted to switch it over to Guix System, to be able to do most of the configuration of my small server in Guile using Guixes tooling for maintenance and systems administration. I'll briefly describe what I did to succesfully boot Guix System in the following. I won't talk about the actual usage of Guix as a DNS, DHCP and Gitolite-Server on a Raspberry Pi for now, but eventually will cover these aspects later.

Guix-HPC Activity Report, 2023

2024-02-16T14:00:00Z

We are pleased to publish the sixth Guix-HPC annual report. Launched in 2017, Guix-HPC is a collaborative effort to bring reproducible software deployment to scientific workflows and high-performance computing (HPC). Guix-HPC builds upon the GNU Guix software deployment tool to empower HPC practitioners and scientists who need reliability, flexibility, and reproducibility; it aims to support Open Science and reproducible research.

FOSDEM and Guix Days 2024

2024-02-11T22:00:00Z

About my personal FOSDEM 2024 experience and Guix Days

Using Guix despite uncooperative HPC admins—the ultimate solution

2024-02-11T00:00:00Z

How do you use Guix on HPC when your friendly HPC admins are uncooperative? This is the ultimate solution.

Announcing the System Crafters Forum!

2024-02-01T08:00:00Z

Today I’m excited to announce the launch of the new System Crafters Forum!

HIP and ROCm come to Guix

2024-01-30T15:30:00Z

We have some exciting news to share: AMD has just contributed 100+ Guix packages adding several versions of the whole HIP and ROCm stack! ROCm is AMD’s Radeon Open Compute Platform, a set of low-level support tools for general-purpose computing on graphics processing units (GPGPUs), and HIP is the Heterogeneous Interface for Portability, a language one can use to write code (computational kernels) targeting GPUs or CPUs. The whole stack is free and “open source” software—a breath of fresh air!—and is seeing increasing adoption in HPC. And, it can now be deployed with Guix!

Videos of the 2023 workshop are on-line

2024-01-29T10:00:00Z

Back in November, the First Workshop on Reproducible Software Environments for Research and High-Performance Computing was held in Montpellier, France. Coming from France primarily but also from Czechia, Germany, the Netherlands, Slovakia, Spain, and the United Kingdom to name a few, 120 people—scientists, high-performance computing (HPC) practitioners, system administrators, and enthusiasts alike—came to listen to the talks, attend the tutorials, and talk to one another.

Guix for machine provisioning and management

2024-01-17T00:00:00Z

This post is about using Guix for the provisioning and management of cloud machines and services. Beyond the official documentation, there are various great tutorials around this topic already, like this one, this one, or this other one. I'm writing this up primarily as a note-to-self, and in case my specific approach can be of interest to anyone else.

Modifying Guix packages using inheritance

2024-01-12T19:52:00Z

Modifications to guix packages using inheritance

Secrets management with SOPS Guix

2024-01-02T16:20:00Z

Dealing with secrets in functional operating systems can range from pretty usable to complete hell. Nix has several answers to this problem, the more integrated of which appears to be sops-nix. After spending some months envying our neighbors grass, I figured it was time for Guix to have its own (attempt at an) answer to the secrets problem.

Monitor your Guix System with Grafana

2023-12-30T16:20:00Z

If you need to run Grafana on the Guix System this post is the right place. In this example we'll setup Grafana to read metrics from the same machine it's run upon, but you can adapt this to use a remote datasource.

Guix introduction at 37c3

2023-12-27T00:00:00Z

This is the outline of a short session on Guix that I had the chance to organise at the 37th Chaos Communication Congress, or 37c3, in December 2023. It's not worth much, but I thought it was useful to have it here in case I want to reuse it or refer to it in the future.

Guix + Zig + NSIS for the win…DOWS?

2023-12-14T22:00:00Z

How I made a program for Windows and GNU/Linux without touching any Windows machine. The tools and the tricks to be effective (Zig and NSIS for the win).

Tame Docker selfhosting with Guix

2023-12-10T16:20:00Z

Many applications are packaged in OCI/Docker images but not in Guix. A good subset of them is written either in NodeJS, Go, Rust or languages that, as a general approach, encourage applications to have huge dependency graphs.

Advanced package transformations in manifests and Derivations introduction

2023-12-08T16:10:00Z

Using with-git package transformations and Derivations introduction

Package transformations in manifests

2023-12-07T11:16:00Z

Modifying applications using manifests and package transformations

Modifying Guix packages using package transformations

2023-12-05T15:43:00Z

Creating package variants using just the command line tools

A side of Guile: The Guile REPL and investigating Guix packages

2023-12-04T10:54:00Z

Introduction to the Guile REPL and querying Guix package information

GNU Mes 0.26 released

2023-12-03T14:00:00Z

We are happy to announce the release of GNU Mes 0.26.

GNU Mes 0.25.1 released

2023-12-02T11:00:00Z

Mes 0.25.1 is a bug-fix release.

Guix package rebuilds

2023-11-28T10:48:00Z

An introduction to Guix packaging - rebuilding Guix packages

Mes released and bootstrappable TCC merged

2023-11-15T22:00:00Z

Some merging and releasing has been done. So here we are.

GNU Mes 0.25 released

2023-11-11T08:00:00Z

We are happy to announce the release of GNU Mes 0.25!

Guix time travelling tricks

2023-11-07T15:57:00Z

Guix time-travel tricks: install any version of a Guix package

Milestone — MesCC builds TinyCC and fun C errors for everyone

2023-10-29T22:00:00Z

We spent the last months making MesCC able to compile TinyCC and making the result of that compilation able to compile TinyCC. Many cool problems appeared, this is the summary of our work.

Time travelling dev environments in Guix

2023-10-17T16:52:00Z

Guix time-travel to guarantee reproducible dev environments

Announcing the First Workshop on Reproducible Software Environments

2023-09-18T14:30:00Z

We’re excited to announce the First Workshop on Reproducible Software Environments for Research and High-Performance Computing (HPC), which will take place in Montpellier, France, on November 8–10th, 2023! The preliminary program is on-line, and now’s the time for you to register!

More work, more people, more energy — thanks NlNet

2023-07-16T21:00:00Z

Now it’s time to focus on combining all the previous work and making it production ready. NlNet for the rescue, again.

Reproducible research hackathon: experience report

2023-07-12T15:20:00Z

Two weeks ago, on June 27th, we held an second on-line hackathon on reproducible research issues. This hackathon was a collaborative effort to bring GNU Guix to concrete examples inspired by contributions to the online journal ReScience C.

Coping with non-free software in Debian

2023-07-11T13:27:00Z

A personal reflection on how I moved from my Debian home to find two new homes with Trisquel and Guix for my own ethical computing, and while doing so settled my dilemma about further Debian contributions.

A guide to reproducible research papers

2023-06-23T12:00:00Z

A core tenet of science is the ability to independently verify research results. When computations are involved, verifiability implies reproducibility: one should be able to re-run the computations to ensure they get the same results, at which point they may want to start experimenting with variants of the computational methods, feed it different data sets, and so on. This is the motivation behind our work on Guix: we want to empower scientists by providing a tool in support of reproducible computations and experimentation.

Scheme Static Site Generators Review

2023-05-23T12:00:00Z

Static site generator is a program, which accepts text files as input and produces static web pages as output. It can be useful in various scenarios: for building blog, book, documentation, project or personal page for example.

Reproducible Research Hackathon—let’s redo!

2023-05-12T12:00:00Z

It's time to run the second Reproducible Research hackathon! The first one was from... 2020, already! The date: Tuesday June, 27th. Start: 9h30 (CEST) End: 17h30.

Unveiling the New System Crafters Site!

2023-05-11T08:00:00Z

Welcome to the redesigned and improved System Crafters site!

Speeding up Guix with a local caching substitution server

2023-05-01T12:39:00Z

Using Guix publish to run a local caching substitution server.

Reproducible dev environments using Guix

2023-04-30T07:19:00Z

Making development reproducible, easy and fun with Guix

Guix shell for virtual environments and containers

2023-04-29T12:26:00Z

Using Guix shell to create isolated environments and containers

How To Trust A Machine

2023-04-29T11:45:42Z

Let’s reflect on some of my recent work that started with understanding Trisquel GNU/Linux, improving transparency into apt-archives, working on reproducible builds of Trisquel, strengthening verification of apt-archives with Sigstore, and finally thinking about security device threat models. A theme in all this is improving methods to have trust in machines, or generally any external entity. While I believe that everything starts by trusting something, usually something familiar and well-known, we need to deal with misuse of that trust that leads to failure to deliver what is desired and expected from the trusted entity. How can an entity behave to invite trust? Let’s argue for some properties that can be quantitatively measured, with a focus on computer software and hardware:

The Full-Source Bootstrap: Building from source all the way down

2023-04-26T16:00:00Z

We are delighted and somewhat relieved to announce that the third reduction of the Guix bootstrap binaries has now been merged in the main branch of Guix! If you run guix pull today, you get a package graph of more than 22,000 nodes rooted in a 357-byte program—something that had never been achieved, to our knowledge, since the birth of Unix.

Support Windows not supporting Windows

2023-03-17T22:00:00Z

About the possibility of having Windows users as clients being a software developer that doesn’t use Windows, and how to solve that technically.

Continuous integration and continuous delivery for HPC

2023-03-06T15:00:00Z

Will those binaries actually work? This is a central question for HPC practitioners and one that’s sometimes hard to answer: increasingly complex software stacks being deployed, and often on a variety of clusters. Will that program pick the right libraries? Will it perform well? With each cluster having its own hardware characteristics, portability is often considered unachievable. As a result, HPC practitioners rarely take advantage of continuous integration and continuous delivery (CI/CD): building software locally on the cluster is common, and software validation is often a costly manual process that has to be repeated on each cluster.

GNU Mes 0.24.2 released

2023-02-15T09:00:00Z

We are happy to announce the release of GNU Mes 0.24.2, representing 25 commits over nine months by four people.

Guix-HPC Activity Report, 2022

2023-02-10T15:45:00Z

This document is also available as PDF (printable booklet).

Guix-HPC at FOSDEM

2023-01-24T14:00:00Z

As has been the case for 9 years (!), Guix will be present at FOSDEM, the big annual free software developer conference in Europe. There will be no less than ten Guix-related talks, of which the following are particularly relevant to the HPC and reproducible research communities:

Layering Guix Profiles

2022-12-23T18:19:00Z

Layering Guix profiles and activating them at login.

Automating and managing multiple Guix profiles

2022-12-22T10:49:00Z

Automating and managing multiple Guix profiles.

Guix Profiles to logically separate packages

2022-12-21T17:45:00Z

Guix profiles to logically separate package sets

Second impressions of Guix 1.4

2022-12-19T21:38:32Z

While my first impression of Guix 1.4rc2 on NV41PZ was only days ago, the final Guix 1.4 release has happened. I thought I should give it a second try, although being at my summer house with no wired ethernet I realized this may be overly optimistic. However I am happy to say that a guided graphical installation on my new laptop went smooth without any problem. Practicing OS installations has a tendency to make problems disappear.

Guix 1.4 on NV41PZ

2022-12-16T11:09:46Z

On the shortlist of things to try on my new laptop has been Guix. I have been using Guix on my rsnapshot-based backup server since 2018, and experimented using it on a second laptop but never on my primary daily work machine. The main difference with Guix for me, compared to Debian (or Trisquel), is that Guix follows a rolling release model, even though they prepare stable versioned installation images once in a while. It seems the trend for operating system software releases is to either following a Long-Term-Support approach or adopt a rolling approach. Historically I have found that the rolling release approach, such as following Debian testing, has lead to unreliable systems, since little focus was given to system integration stability. This probably changed in the last 10 years or so, and today add-on systems like Homebrew on macOS gives me access to modern releases of free software easily. While I am likely to stay with LTS releases of GNU/Linux on many systems, the experience with rolling Guix (with unattended-upgrades from a cron job to pull in new code continously) on my backup servers has been smooth: no need for re-installation or debugging of installations for over four years!

Using manifests to maintain our Guix applications

2022-12-12T21:49:00Z

Installing applications in Guix with manifests

Installing Guix on a 10th gen Thinkpad X1

2022-12-05T11:00:00Z

The last time I bought a laptop, I got a used Thinkpad X220 from eBay. I loved that laptop, but time marches on and old hardware eventually becomes too slow for modern development needs. After a lot of indecision, I bought a 10th generation Thinkpad X1 with an Intel Core i7-1280P CPU, 32GB RAM, and 1TB NVMe SSD. While they don’t make Thinkpads like they used to, I’m still really happy with it and glad I chose it. Despite the keyboard changes, the TrackPoint™ is still there and I don’t think I could feel good using a laptop without it. Below I will explain all the steps I took to get the Guix distribution setup nicely on it. Maybe it can help you setup your own Thinkpad X1 or some other computer that requires more than what Guix provides for all of the hardware to work.

Installing Chrome and other proprietary apps on Guix

2022-12-04T15:06:00Z

Using channels to find more apps on Guix - including proprietary ones from the nonguix channel

GNU Mes 0.24.1 released

2022-10-16T11:00:00Z

We are happy to announce the release of GNU Mes 0.24.1, representing 23 commits over five months by four people.

On language bindings & Relaunching Guile-GnuTLS

2022-10-14T13:58:43Z

The Guile bindings for GnuTLS has been part of GnuTLS since spring 2007 when Ludovic Courtès contributed it after some initial discussion. I have been looking into getting back to do GnuTLS coding, and during a recent GnuTLS meeting one topic was Guile bindings. It seemed like a fairly self-contained project to pick up on. It is interesting to re-read the old thread when this work was included: some of the concerns brought up there now have track record to be evaluated on. My opinion that the cost of introducing a new project per language binding today is smaller than the cost of maintaining language bindings as part of the core project. I believe the cost/benefit ratio has changed during the past 15 years: introducing a new project used to come with a significant cost but this is no longer the case, as tooling and processes for packaging have improved. I have had similar experience with Java, C# and Emacs Lisp bindings for GNU Libidn as well, where maintaining them centralized slow down the pace of updates. Andreas Metzler pointed to a similar conclusion reached by Russ Allbery.

Guix for development

2022-09-23T15:00:00Z

This wonderful article by Marius Bakke (thanks for using Haunt btw!) about guix shell hit the orange website front page recently. I left a comment to the effect of “hell yeah I use it for all my projects!” and someone asked me for an example of what I do. I sent them some links but I thought hey, this could be a blog post and I haven't written one of those in years!

Milestone – RISC-V support in Mes’s bootstrappable TinyCC

2022-09-21T21:00:00Z

Bringing RISC-V support to the bootstrappable TinyCC Mes forked. Some problems and a look into the future.

Guix common workflows and concepts

2022-09-09T20:49:00Z

Common workflows when using the Guix package manager

Adding TinyCC to the mix

2022-07-31T21:00:00Z

Discussing what changes need to be done to make GCC compilable form a simpler C compiler, TinyCC.

Milestone — Source to Binary RISC-V support in GCC 4.6.4

2022-06-19T21:00:00Z

Description of the changes applied from a minimal compiler that runs and generates assembly to something that is actually able to compile, interacting with binutils and having a working libgcc.

Dealing with possessed TrackPoints on later model ThinkPads

2022-06-19T01:51:00Z

On a new-to-me ThinkPad T440p, I’ve had the worst time with the TrackPoint.

GNU Mes 0.24 released

2022-05-02T20:00:00Z

We are thrilled to announce the release of GNU Mes 0.24, representing 222 commits over one year by four people.

Milestone — Minimal RISC-V support in GCC 4.6.4

2022-04-07T21:00:00Z

Description of the changes for a minimal RISC-V support in GCC-4.6.4 and how did I reach this point.

ELF format — why not?

2022-03-13T22:00:00Z

Some introduction to ELF as we’ll need to deal with this in the future.

GCC internals — From a porting perspective

2022-03-07T22:00:00Z

Deep diving into GCC’s internals from the perspective of someone who wants to port GCC for a new architecture.

Git patches by email

2022-03-07T15:06:00Z

Using a patch workflow

GNU Mes 0.23.1 released

2022-03-01T17:00:00Z

We are happy to announce the release of GNU Mes 0.23.1, representing 22 commits over one year by four people.

Guix package management on Ubuntu

2021-09-26T10:26:00Z

Guix package management as an alternative to using Snap or Flatpak packages

RISC-V Adventures II: hex0

2021-06-07T21:00:00Z

A love story about trust, machine code, hexadecimal notation and weird instruction formats, with an epic unexpected solution coming back from the afterlife.

RISC-V Adventures: Lightening

2021-05-18T21:00:00Z

The port of Lightening, the code generation library used in Guile Scheme, and other adventures on the low level world of RISC-V.

Review of 2020

2021-05-15T21:00:00Z

The review of our year 2020 at ElenQ Technology.

GNU Mes 0.23 released

2021-03-14T17:00:00Z

We are happy to announce the release of GNU Mes 0.23, representing 125 commits over one year by four people.

We did it!

2021-01-07T08:00:00Z

Last Monday I sent an update essentially saying $Subject:

Childhurds and GNU/Hurd substitutes

2020-10-08T14:15:00Z

A lot has happened since our Hello Hurd post beginning of April. No, not nearly as much as we joked on April 1st , but more than enough to share and be proud of.

Guix Further Reduces Bootstrap Seed to 25%

2020-06-15T12:00:00Z

We are delighted to announce that the second reduction by 50% of the Guix bootstrap binaries has now been officially released!

ElenQ Donations — Intro + GNU Guix

2020-05-24T21:00:00Z

Recent ElenQ Technology donation to the great GNU Guix package manager and software distribution

Guix System on the Pinebook Pro

2020-02-15T00:00:00Z

Guix, Nix: You are in a maze of twisty little $PATHs, some undefined

2019-07-24T06:48:00Z

Some notes on interactive fiction/text adventure games and PATHs in Guix, and StumpWM.

Reproducible Builds Workshop: Paris 2018

2018-12-15T12:31:17Z

I travelled to Paris over the last week for the Reproducible Builds workshop there, as well as a GNU Guix meetup on the day before. All in all, it's been awesome, if a little tiring.

Confusion: PDP-10 Zork

2018-09-24T04:52:00Z

I grew up playing Infocom, Magnetic Scrolls, and Level 9 text adventures, with the Zork trilogy, the Enchanter trilogy, Planetfall, Wishbringer, The Guild of Thieves, The Pawn, Knight Orc, and Silicon Dreams being particularly prominent in my memory (somewhat re-activated through recent listening to the Eaten by a Grue podcast). I would have played all of these on an Atari 8bit or ST computer, and didn’t have any access to anything like a mainframe, and so never actually played the original Zork, which was written in the Lisp-derived MDL language (which formed the basis for the MDL-subset Infocom-specific ZIL language used for their subsequent offerings) for the DEC PDP-10.

Dockerised Firefox on GuixSD

2018-09-16T02:18:00Z

So GuixSD doesn’t currently package Firefox (though hopefully that is changing), but only IceCat (which is now EOL). On freenode#guix, pkill9 suggested that Firefox (and Chromium etc.) could be installed on Guix via the Nix installer (install as per instructions on their site and then nix-env -i firefox) with the following trick, create a file ~/.local/bin/firefox with the following content:

Guix: You are in a maze of lispy little passages, (map equal? ′(′all ′alike) ′(′all ′alike))

2018-08-05T02:47:00Z

So I finally made a serious go of running GuixSD, a GNU Linux distro which is largely built on GNU Guile Scheme (a dialect of Lisp) on one of my machines (one I had actually put together with GuixSD in mind: an X200 Thinkpad, which I Libreboot‘ed and put a Atheros Wi-Fi card in), and, to increase both the quantity and variety of Lisps involved, am trying to use with StumpWM (which is written in Common Lisp).

I will be presenting about GNU Guix at LibrePlanet 2018

2018-03-10T20:30:00Z

If you're in the Cambridge, MA area or already planning to attend the LibrePlanet 2018 free software conference, come learn about functional package management at my talk: Practical, verifiable software freedom with GuixSD.

First few months with my Librem 13

2018-01-27T12:21:37Z

Bytemark server with GuixSD

2017-12-08T19:56:50Z

Freenode #live

2017-10-31T19:51:45Z

The first Freenode #live conference happened on the weekend just passed (28th and 29th of October), and it was awesome but exhausting.

Ruby on Guix

2015-08-30T15:00:00Z

I’ve been working with Ruby professionally for over 3 years now and I’ve grown frustrated with two of its most popular development tools: RVM and Bundler. For those that may not know, RVM is the Ruby version manager and it allows unprivileged users to download, compile, install, and manage many versions of Ruby instead of being stuck with the one that is installed globally by your distro’s package manager. Bundler is the tool that allows developers to keep a version controlled “Gemfile” that specifies all of the project’s dependencies and provides utilities to install and update those gems. These tools are crucial because Ruby developers often work with many applications that use different versions of Ruby and/or different versions of gems such as Rails. Traditional GNU/Linux distributions install packages to the global /usr directory, limiting users to a single version of Ruby and associated gems, if they are packaged at all. Traditional package management fails to meet the needs of a lot of users, so many niche package managers have been developed to supplement them.

Reproducible Development Environments with GNU Guix

2014-11-08T22:00:00Z

If you’re a software developer, then you probably know very well that setting up a project’s development environment for the first time can be a real pain. Installing all of the necessary dependencies using your system’s package manager can be very tedious. To "solve" this problem, we have resorted to inventing new package managers and dependency bundlers for pretty much every programming language. Ruby has rubygems and bundler, Python has pip and virtualenv, PHP has composer, node.js has npm, and so on. Wouldn’t it be nice to instead have a single package manager that can handle it all? Enter GNU Guix, a purely functional package manager and GNU/Linux distribution. Using Guix, you can easily create a development environment for any software project using the guix environment tool.

First GNU Guile Patch and More Guix Packages

2013-11-22T21:00:00Z

I have spent some of the last month working on contributing to GNU Guile and now I can finally say that I have contributed code to the project. Guile has several hash table implementations: a Guile native one, SRFI-69, and R6RS. SRFI-69 contains a handy procedure, alist->hash-table, which allows for a sort of hash literal-like syntax:

My First GNU Guix Patch

2013-10-16T21:00:00Z

Over the weekend, I decided to try out GNU Guix: A fully functional package manager based on Nix and a distribution of the GNU system. I’m a big proponent of GNU Guile, thus I was excited to see a DSL for package management written with Guile.