Aloys' corner

WasmOS: implementing a virtual monitor

2026-10-15T20:02:00Z

Things are slowly starting to fall in place with my idea of an "OS" in the browser. The idea is to create a "kernel" on top of the WASM runtime. Hardware will be emulated by the browser and/or JS, and maybe extended to WASI compatible runtime in the future.

Being a visual person, my first victim is the display.. The canvas will act as a monitor, receiving a framebuffer from the "kernel" written in Zig.

I'm completely out of my league here, so my apologies if the terminology is approximate. I expect to read this in a year and think: "You know nothing, John Snow"

WASM Component Model: the future of SDKs?

2026-10-14T14:12:00Z

I started digging into WASM, and its component model.

This feels like a dream for SDK: you could implement a SDK into one language, and have it run in many languages and environment.

It's still too early to say if this will go anywhere, but it does have very attractive aspect to it, such as using the right language for the right component, rather than whatever the language is written in.

WasmOS: Introduction

2026-10-12T18:06:00Z

I am a 'self-taught' developer.

I put 'self-taught' between quotes because I didn't teach myself: the internet was full of excellent resources to learn to code¹.

Product of my era, I learned to code with React circa 2017. It was great for a while and I had a lot of fun grokking React and its ecosystem.

Fortunately, being curious by nature, I didn't stop there and slowly worked my way down² the stack as time went on. I developed a knack for good UI and UX and worked as a UX engineer. I then moved onto full-stack roles, and dipped into infrastructure and devops. Self-hosting came next and with it, a dabble of networking.

However, almost ten years later I still had not a complete understanding of what was going on under the hood. I always worked at a high level of abstraction.

Fast forward to today, I am now finally getting into low level programming and I am currently going through the excellent OSTEP book. This lead me to this idea of WasmOS.

WasmOS is (or rather, will one day be, maybe?) a virtual OS running in the browser.

It is purely an educational and experimental project.

It won't be a complete OS, there are obvious limitations to creating a virtual OS in a browser.

Goal

WasmOS is an educational and experimental project.

The overarching idea is to expand my circle knowledge while having fun.

In particular, I wish to:

acquire experience with lower level system programming,
find an excuse to use zig,
build a deeper understanding of the underlying machine,
combat 'AI' fatigue,
follow my curiosity,
document my way through my learnings,
create an endless project to tinker on, without boundaries or deadline,
recreate the now extinct magical feeling of creating things by typing on a keyboard in a flow state while listening to good tunes (RIP),
go slow and go deep,

The project has no real world application, this is a purely curiosity-driven project.

It might not (and most likely won't) be useful beyond the intellectual stimulation of pursuing a lofty goal.

Rules

Given the nature of the project, these are the rules I am setting to ensure the project is successful³

No LLM to generate or review code

Niet. Nada. Nope. Rien.

LLMs may have a place when there is a time-bound or financial goal. Maybe.

But in this case, the use of LLMs to generate the code would be entirely counter-productive to the success of this project.

Every line of (questionable) code in this repo will be handwritten by myself.

No LLM generated code. No exception.

No LLM to research or validate ideas

I have no idea what I'm doing here, and that's the point!

I intend to not use LLM to do any research or validation of my theory so I can fail.

I want to fail. Failing is good.

Avoiding LLMs will push me to come up with my own theories and mental models, and test them out.

I expect to be in struggle-city a lot on this project, and that's by design.

Failing is becoming a luxury in the LLMs age, I believe it's robbing us of creating expertise in many cases.

I will still use books and internet, but I will not use any LLM-driven chatbot.

No time limits

This is intended to be an ongoing experiment.

I might choose to terminate it early - or I will never finish it.

I won't put any deadlines on myself and approach it with a slow productivity mindset.

In the current insane pace of the modern world, I want to create an environment where things take the time they take.

Go slow or go home.

Devlog

As I'm writing this, in October 2026, I don't know much about operating systems.

I am about one third of my way through the awesome OSTEP book, but that is as far as my experience goes with operating system.

I am a web developer, not a system programming expert (yet!). And what an opportunity!

LLMs have robbed us of the beginner's trough (which is a tragedy in my opinion).

Nothing like a fresh start, when you have no idea what you're doing and you suck at it. That's the dreamer's stage, nothing is impossible.

As part of this project, I will be writing a devlog of my progression as I go along.

I will do my best to describe my thinking; I expect to write stupid ideas and be often incorrect, but I'm looking forward to it.

This will give me the opportunity to improve my written communication, cement the knowledge I acquire, and give me the opprtunity to look back in a few years and think: "Man, I have come a long way!".

There is nothing as satisfying to me as looking back and seeing the progress you made.

In my opinion, the journey is the most important part of any endeavor, be it life, or a geeky pursuit like this.

Have fun

Finally, the most important rule: this is about having fun - there is no expectations here.

Where to start?

That's a good question. I don't really know where to start!

The first question I need to answer is: what part of the OS can I realistically build in WASM? What does an OS in WASM look like?

My first task is to do some research about WASM and see what it is all about.

The second, is simply to set up a Zig development environment.

I did the Ziglings about a year ago, but I haven't used it or touch it since then. I won't do them again, I am just going to use a refresher and learn as I go.

Alright, I will be back once I have a clearer picture of what I am actually trying to build here.

Footnotes:

unfortunately, it seems that software engineering education content was another victim of 'AI'

or sideways, I guess?

my definition of success is to expand my circle of knowledge while having fun

Grieving the loss of details

2026-10-12T09:29:00Z

Alisa Sireneva's blog post is saddening. It reflects the current loss of meaning in the software industry that some of use are experiencing Some people thrive with the advent of LLM, I don't.

As stated in my AI manifesto, I use it at work when I believe it in the interest of my employer. I don't enjoy it; but if there is clear upside for my company, then I believe it is my duty to use it.

However, the definition of a "clear upside" is hard to define. The gain of speed at the cost of loss of comprehension of the codebase is a particularly hard one to judge.

In the comments on HackerNews, there is one that is really potent:

I agree with many perspectives in this thread. I empathize with OP. I’m scared about the future of my job and already feel it less fulfilling, despite being more productive than ever.

But I have one singular counterexample to most scary narratives and essays about LLMs writing software, which is my coworker who hardly uses LLMs at all. At least, he hardly uses them compared to me. He still writes most of his code by hand. He still greps around the codebase without claude code. Like he’s definitely using claude code, but only for like one-off specific tasks.

He’s a totally average developer, like everybody else on my team (including me). But he’s clearly more helpful than the rest of us. When people from other teams have questions about how something works, he’s always the first to respond. He’s always the one providing useful context in planning calls. He catches stuff in code review that I didn’t catch, and claude/copilot didn’t catch.

I think I’ve leaned too far into AI, partly because I’m a lazybones and am kind of burned out already. But there’s a stark contrast between me and my coworker that there didn’t used to be. I think the context rot is really setting in, and getting worse. So I think there’s still value in caring about the details.

This is something I struggle with. There is an undeniable gain of speed when using LLM in my work, but it's not free. The cognitive debt is stacking rapidly. It's too early to know if this an acceptable risk or not.

Toying with Elm

2026-10-11T18:46:00Z

On another note, I'm currently building a basic tetris clone in Elm. I don't think I'll continue to use Elm in the future; I believe WASM will make it less relevant. I always wanted to try it out, it has been on my radar for a few years.

It's very enjoyable, and overall, a very nice language.

I will do a proper "review" of it once I finish the tetris clone, mostly likely in the coming week.

Surflog:

2026-10-11T18:42:00Z

A friend gifted me a shortboard, and man, it is a different sport from longboarding! It's fun, but the technique is very different: the drop in is much later and deeper. You need bigger and steeper waves. So far I can't really surf it; I'm mostly getting wiped out - but I'm having a ball. I still love longboarding, but I can see myself picking up the shortboard this summer as the swell builds up.

Book review: 451 Fahrenheit by Ray Bradbury

2026-10-02T09:20:00Z

This is a rather short book from Ray Bradbury. I had never heard about it, but it seems quite popular. It's in the line of 1984 by George Orwell.

The novel is taking place in a dystopian future where the state "enslave" their citizens by destroying knowledge and promoting a hedonic lifestyle.

The protagonist is a fireman. However, in this future, the firemen don't put fires down. Their jobs is to burn books. Owning books is forbidden. In this world, knowledge is evil and ignorance is bliss. Citizens numbs themselves by watching TV shows without any meaning. They wear portable audio devices (i.e. earbuds!) pouring endless ads in their ears around the clock. Then, they take pills to get to sleep. They don't think for themselves - they don't even remember much about who they are.

The book was written in 1953 (!), and it gave me an eerie feeling of similarity with some of what is happening in the current world. We put convenience and pleasure at the top of our priorities to the detriment of the pursuit of harder, more tenuous but also more rewarding activities.

It reminds me of the current mindset around LLMs. We celebrate ignorance: "Look, I don't even know how to do X, yet I made Y. How great!".

The Greek had a word for this, Amathia, which means "willful ignorance". I believe it is a very slippery slope.

I won't spoil the end of the book; however after the last few pages we can only wonder if this ignorance was worldwide, or if the protagonists lived in an ignorance prison which prevented them from seeking a better way to live.

I highly enjoyed the book. I am especially impressed with the creativity of the writer, and how 73 years later it is still relevant.

Enjoyment grows with skills

2026-09-29T17:51:00Z

Today I was reflecting on the enjoyment we draw from activities. Enjoyment tends to grow with skills: the better you are at something, the more enjoyable it becomes. I have observed this with my own person across a wide range of activities, including extremely mundane and/or repetitive ones.

I find that the mindset really matters: when we suck at something, forcing ourselves to enjoy the learning curve is very important. Over time, as skills build, we can get more creative with the activity, get in the flow, or enjoy the new skills acquired.

Smiling, when starting something and sucking at it, is a great trick.

I have surfed on and off for the last 10 years, and frankly, I sucked at it for a very long time. After deciding to invest time into it this year and surfing 3 to 5 times a week, my skills have grown a lot. I still suck - and if I didn't enjoy sucking at it, I would have given up. However I stuck to it. Today I can really enjoy longboarding and I am glad I didn't throw the towel.

I can't help but link this to the loss of joy I have with programming when using LLMs. We trick ourselves in trying to jump over the learning phase, and there is little joy in it.

Using it for areas I would consider myself an expert, such as React, is not as damaging.

[I am putting my thoughts on the screen as they appear - so this is a bit of an omelette of ideas!]

Finished the first "section" of OSTEP: CPU virtualisation

2026-09-22T20:12:00Z

OSTEP (OS in three easy pieces) is a great read so far; I have learnt a lot through the first section which covers CPU virtualisation and scheduler. I am excited to get into the section about file systems and memory.

Working on the "thing" is not doing the "thing"

2026-09-21T11:16:00Z

I have done extensive work on the blog and my "microblog" section was out of order. I fell into the typical trap where ones spends more time tweaking the blog than actually writing!

Replacing elfeed with newsticker (built-in)

2026-09-15T17:11:00Z

Intro: Are my decisions, mine?

Skip this if you are only here of the Emacs bits!

The other day someone asked me what I chose caddy over nginx for my reverse proxy.

That's a great question, why?

Caddy has some great quality-of-life features, such as configuring TLS out of the box for you whereas nginx does not.

But how hard is it to configure TLS? Well, I wouldn't know. I never used nginx.

And here is the interesting part. Why did I choose caddy, if it solves a pain I never felt?

The truth is, I didn't choose caddy; I let others choose it for me.

I read online somewhere that someone was using caddy, and simply followed.

And this prevented me from investing a few hours in understanding how to setup TLS for a domain using an ubiquitous and trusted, widely available technology.

It's intriguing that I went straight to get the solution to a problem I didn't have.

In this case, it is not an issue: caddy is a great tool.

But it made me wonder: how often my thoughts are truly mine? How often my decision are mine?

I consume tons of information. I read a lot. Listen to many podcasts.

It feels like thinking, but is it? I am not so sure.

I want to cultivate my critical thinking. I believe it's a muscle that is easy to not exercise in our modern world.

For the last few months, I have started to really try to protect my thinking space fiercely.

For example I turned off comments on Youtube by default. I avoid listening to podcast first thing in the morning. I write a book review before looking at what others think of the book.

I want to force myself to think before yielding my thinking to some strangers online.

This is my frame of mind for deciding to give newstickers a go rather than using elfeed.

My newsticker configuration

This is my configuration:

olivetti-mode is enabled (it centers the text, a.k.a. 'Zen mode'¹), and the article window is selected.
variable-pitch-mode is enabled to improve readability.
TAB and S-TAB are set to jump to links (and back). Once on a link, Enter will open the link at point in eww.
q is set to newsticker-treeview-quit everywhere, so all newstickers buffers are closed.
the mode-line are hidden to remove distraction. I have thin borders to keep each window distinct.

I played with the idea of modifying newsticker--treeview-window-init to use vertical panes for the list of articles to mimick elfeed, but in the end I prefer the layout proposed by newstickers. It is a bit on the heavy side

Now I hit "C-c e e" and newstickers opens. I use f and F to selected my next or previous feed. n and p to select the next article of the current feed, or N to select the next unread of any feed. Finally, I can use i to mark an article as "immortal" so it is never removed.

This does everything I need from my RSS feed.

(use-package newsticker
  :bind
  (("C-c e e" . #'newsticker-show-news))
  :hook
  ((newsticker-treeview-item-mode . my/setup-newsticker)
    ((newsticker-treeview-mode
       newsticker-treeview-list-mode
       newsticker-treeview-item-mode) . my/hide-mode-line))
  :preface
  (defun my/hide-mode-line ()
    (setq mode-line-format nil))
  (defun my/setup-newsticker()
    (olivetti-mode)
    (variable-pitch-mode)
    ;; Focus on the article window
    (select-window (newsticker--treeview-item-window)))
  :config
  ;; Set the key TAB and S-TAB to be bound to shr-next-link and shr-previous-link to cycle through links easily
  (keymap-set newsticker-treeview-item-mode-map "TAB" #'shr-next-link)
  (keymap-set newsticker-treeview-item-mode-map "<backtab>" #'shr-previous-link)
  ;; set q to quit tree view (I only use tree view)
  (keymap-set newsticker-mode-map "q" #'newsticker-treeview-quit)
  ;; hide the mode line on newsticker-mode and newsticker-treeview-mode
  (add-to-list 'display-buffer-alist
    '((or (derived-mode . newsticker-mode)
          (derived-mode . newsticker-treeview-mode))
       (display-buffer-use-some-window)
       (window-parameters . ((mode-line-format . none)))))
  :custom
  (newsticker-automatically-mark-items-as-old nil) ;; Only mark as old (read) when opened
  (newsticker-url-list
    '(("Derek Sivers" "https://sive.rs/en.atom")
       ("Drew DeVault's blog" "https://drewdevault.com/blog/index.xml")
       ("Fritz Gabo" "https://fritzgrabo.com/posts/rss.xml")
       ("Joshua Blais" "https://joshblais.com/index.xml")
       ("mccd.space" "https://mccd.space/feed.xml")
       ("Ploum" "https://ploum.net/atom_en.xml")
       ("Ratfactor Feed" "https://ratfactor.com/atom.xml")
       ("Sophie Koonin" "https://localghost.dev/feed.xml")
       ("Sourcery Zone" "https://sourcery.zone/index.xml")
       ("Xenodium, solopreneur and emacs" "https://xenodium.com/rss")
       ("マリウス" "https://xn--gckvb8fzb.com/index.xml")
       ("James Cherti" "https://www.jamescherti.com/feed/")
       ("Planet Emacslife" "https://planet.emacslife.com/atom.xml")
       ("Wai Hon's Blog" "https://whhone.com/index.xml"))))

Thank you for reading, Aloys.

Footnotes:

Surely I could write my own Olivetti?

Increase the TTY font on Asahi Linux

2026-09-11T17:31:00Z

My personal laptop is a Macbook M1 running Asahi linux.

When starting the laptop, the font on the TTY is ridiculously small, as the resolution of the screen is very high.

I wanted to use a bigger font, and this is how I solved the issue.

Find a font and try it out

The first step is to find the fonts installed on your system. You can find them in /usr/lib/kbd/consolefonts.

Most fonts will have an indication of the size in their name, the number representing the size.

For example latarcybheb-sun16 would be 16px high, as opposed to latarcybheb-sun32 being 32px.

You can try the font out by jumping into another TTY via Ctrl + Alt + F<n> where <n> is the TTY number, e.g. Ctrl + Alt + F2 will switch to the second TTY¹.

Then type setfont <my-font> to try out a font. Replace <my-font> with the desired font, such as:

setfont latarcyrheb-sun32

Set the font permanently

In order to set the font permanently you need to edit two files:

The configuration file for the virtual console (man 5 vconsole.conf).
Modify and Regenerate the GRUB configuration file (man grub-mkconfig).

Virtual configuration file

In /etc/vconsole.conf, modify the FONT variable such as:

KEYMAP="us"
FONT="latarcyrheb-sun32" # <-- the chosen font

Grub configuration file

In /etc/default/grub, append to GRUB_CMDLINE_LINUX_DEFAULT "vconsole.font=<my-font>" such as:

GRUB_DISABLE_SUBMENU=true
GRUB_DISABLE_RECOVERY=true
GRUB_DISABLE_OS_PROBER=true
GRUB_CMDLINE_LINUX_DEFAULT="rootflags=subvol=root vconsole.font=latarcyrheb-sun32" #<-- Append the font chosen here
GRUB_DISTRIBUTOR="Fedora Linux Asahi Remix"
GRUB_ENABLE_BLSCFG=true
GRUB_GFXMODE=auto
GRUB_TERMINAL_INPUT="console"
GRUB_TERMINAL_OUTPUT="gfxterm"
GRUB_TIMEOUT=5
GRUB_TIMEOUT_STYLE=menu
GRUB_DEFAULT=saved

Then regenerate the configuration by running grub2-mkconfig:

sudo grub2-mkconfig -o /boot/efi/EFI/fedora/grub.cfg

That's it! Now reboot your system and you should see the new font configuration.

I chose latarcybheb-sun32 as it is large enough to read, and look standard.

Footnotes:

TIL, this is a pretty handy tip!

Chrono Trigger

2026-09-01T07:17:00Z

I finished Chrono Trigger this weekend. I am not a gamer, but we purchased a gameboy / NES emulator a few months back and it has been a great source of entertainment; even tough sometimes, it sits on the shelf for weeks without being touched.

I picked up Chrono Trigger about two months ago, and it has been an absolute joy to play it. The game is over 30 years old! It aged beautifully.

I beat the game this weekend but I am sure I will give it another go in the future.

Friction and constraints are good.

2026-08-24T18:33:00Z

Adding syntax highlighting to my blog via Haunt and guile-syntax-highlight: challenging!

2026-08-21T19:38:00Z

Challenging, but slowly getting there. There is not other way but to read the source code.

Scheme is starting to click, and reading it is becoming easier everyday. It's growing on me.

Emacs is the gift that keeps on giving

2026-08-19T12:23:00Z

The learning curve of emacs was quite steep; in a way, steeper than (neo)vim. Vim is clearly an editor, whereas emacs is a lisp interpreter with text editing capabilities.

This makes its footprint much larger, making the upfront learning cost higher.

However, it seems to make its reward comparatively higher as emacs and elisp start to click.

I absolutely enjoy it, and rarely open vim these days.

AI;DR: AI; Didn't read

2026-08-18T07:55:00Z

Rick Manelius on reading AI material. Whatever your stance is on generative AI, this is relevant. I totally follow the AI;DR policy.

If it's not worth the time writing, it's not worth the time reading.

Writing a Guix service from scratch, as a beginner

2026-08-17T22:29:00Z

I am in the middle of migrating my machines from NixOS to Guix.

My first milestone is to migrate my VPS to Guix.

My VPS has essentially three majors roles:

host my email server.
host my wireguard server.
act as a proxy server to access services on my home server (thus, hiding my home IP).

The mail server is up and running, using exim as the MTA and dovecot as the IMAP server. I had to jump through a few hoops to get exim up and running. I would have preferred postfix over exim, but only exim is available out of the box on the official Guix channel.

At the time, I didn't know how to define my own custom services. I intend to use Guix for the foreseeable future, I want to build a deep understanding of it. Learning to create my own services, suited to my own needs, is an important part of mastering Guix.

Which brings us to the motivation behind this article: the time had come to create my own service.

For the proxy server, I enjoy using Caddy. Caddy isn't available as a service on Guix.¹

This seems like the perfect time to finally dive into custom services.

As I navigated my way through the docs and the source code, I decided to document my learning and share it here, as guide for other newcomers.

In this article, we will be writing a custom service for our Caddy reverse proxy.

This service involves setting up a configuration file for Caddy via Guix, creating a system user and configuring Shepherd to run the daemon.

It's a perfect first custom service: t is simple enough to ease into custom services, yet it includes a good overview of them.

Furthermore, most of the services I run on my home server are essentially a combination of those three actions: configure users, manage configuration files and run the daemon.

Who is this for?

This article is suitable to Guix newcomers and beginners. As a matter of fact, I wrote this as I went along, stumbling my way through it, without any extensive knowledge beyond reading the documentation.

Pre-requirements

The only true prerequisite is to have the Caddy package ready to go on your Guix instance, so we can build the service on top of it. At the time of writing this blog, the Guix repository doesn't contain the Caddy package but the team is working on it.

In the meantime, you can follow my blog post to create one easily. It only takes a few lines of code.

You don't need to have a high proficiency or deep expertise in Scheme (I certainly don't), but a basic understanding of it is highly recommended.

I assume that you are, like me, fairly new to Guix - however this isn't a replacement to the documentation. I will be paraphrasing the documentation a lot with my own interpretation of it. I encourage you to keep the documentation on the side while following this article.

I obviously assume that you have Guix installed and a working configuration. If not, you can find one here.

Finally, you need to know how to reconfigure your system (hint: sudo guix system reconfigure my-config.scm).

When I reference the Guix source code, I will use the notation file-name:line.

The plan

Alright, with this out the way, let's talk about what we are concretely going to build here.

In order to keep things as simple as possible, I decided to define our service to be as simple and bare-bones as possible.

Our plan will be as follow:

Define an empty service, and successfully "enable" it.
Create the dameon user and group..
Copy the Caddy configuration to the right location.
Configure Shepherd to run the service as a daemon in the background.

This is the bare mininum Caddy service; it will do the job, but it won't be the most elegant.

Most of the configuration options will be hard coded; the service won't be ready to be distributed. However, it will be functional and fulfill our needs.

Once completed, we can expect to have accumulated enough knowledge along the way to revisit, refactor and improve it.

As soon as this article is out, I plan on improving it and if I feel brave, I might even propose it to the Guix repository.

But for now, let's stick to the basics. We don't want to let perfection get in the way of done.

What is a service?

The documentation defines a service as "something that extends the functionality of the operating system".

This definition is quite vague, but that's because a service can have a wide variety of functionalities. The most obvious type of a service is a daemon running a process in the background (our case), but it's not the only type of service.

As we will see, a service can be a process which is run once, such as creating accounts or copying files to the store. It can be a recurring process, such as a cron job.

In a way, it is a primitive to configure our system in a declarative manner.

One interesting aspect of services, is that they are designed from the ground up to be extensible and composable. A service can extends one or more services, and can itself be extended by one or more services. We will dive a deeper on that subject further below; I find this architecture fantastic.

You can read more about services in the documentation. If you still don't quite understand the concept of services,, it's completely normal. It didn't click for me until I started writing this Caddy service.

So if you don't fully grasp what a service is yet, follow along, it will make more sense as we progress.

1. Define an empty service

Our first step is to break the ice by creating the simplest service we can: a bare service that does nothing. The goal is just to get familiar with services.

First, we need to define the service type of our service.

A service type is essentially a blueprint for a service. Think of it as what a class is to an instantiated object.

A service is enabled or "instantiated" (if we keep our analogy of classes) by the service procedure. The service procedure takes as an argument a <service-type> record and a value.

(service my-service-type my-service-value)

If a value isn't provided, the default-value defined in the <service-type> definition is used.

(service my-service-type) ;; this service is using the default-value defined in <my-service-type>

To enable the service, we add it to the list provided to the services procedure:

(services
  (append (list (service my-service-type my-service-value)) %base-services))

Now let's look inside the <service-type> record.

You can find the definition of <service-type> in gnu/services.scm:187. The service type is well documented, but grepping the codebase is very valuable tool when working with Guix (or any other software if you ask me!).

(define-record-type* <service-type> service-type make-service-type
  service-type?
  (name       service-type-name)                  ;symbol (for debugging)
  ;; Things extended by services of this type.
  (extensions service-type-extensions)            ;list of <service-extensions>
  ;; Given a list of extensions, "compose" them.
  (compose    service-type-compose                ;list of Any -> Any
    (default #f))
  ;; Extend the services' own parameters with the extension composition.
  (extend     service-type-extend                 ;list of Any -> parameters
    (default #f))
  ;; Optional default value for instances of this type.
  (default-value service-type-default-value       ;Any
    (default &no-default-value))
  ;; Meta-data.
  (description  service-type-description)         ;string
  (location     service-type-location             ;<location>
    (default (and=> (current-source-location)
               source-properties->location))
    (innate)))

We notice that the <service-type> requires a name and a list of extensions. It also contains optional fields: compose, extend, default-value, description and location.

Let's define our caddy-service-type. We set the name of our service to 'caddy. We also set the extensions to nil (the empty list), which means that we aren't extending any existing services for now. We also leave the default-value to nil.

Regarding the optional fields, let's only care about the description for now. It takes a string and is used for - you guessed it - the description.

I will cover the compose, extend and extensions fields later, let's not worry about them for now.

Our <service-type> for our Caddy service looks like this:

(define caddy-service-type
  (service-type
    (name 'caddy)
    (extensions nil) ;; an empty list
    (default-value nil)
    (description "Caddy is an extensible server platform that uses TLS by default.")))

That's it. This is the simplest service type: it only has a name and a description.

Let's enable it by adding it to the services procedure.

;; config.scm
(use-modules (gnu))
(use-service-modules networking ssh)
(use-package-modules screen ssh)

(operating-system
  (host-name ...)
  (timezone ...)
  (locale ...)
  (bootloader ...)
  (file-systems ...)
  (users ...)
  (packages ...)
  (services (append (list (service ....)    ;; Pre-existing services
                      (service caddy-service-type)) ;; <-- Add this line here
              %base-services)))       ;; %base-services are the default services

Now, run sudo guix system reconfigure config.scm and celebrate your first custom service.

We "instantiated" a service of type caddy-service-type without a value, defaulting to the default-value of nil.

It's not doing anything, but it still is a service.

If you have a graphical display, you can run the following command to generate a graph of your system:

guix system extension-graph config.scm | guix shell xdot -- xdot -

You will notice that the Caddy service is present in your services. Nice. Now let's make that service do something useful.

2. Create the daemon user

The next step to improve our service is to instruct it to create the caddy user and group.

It is always a good idea to create a non-root user to run a background process: if the process is compromised, the area of attack is much smaller.

This user will:

Start the daemon.
Have read access to the Caddy configuration file.

In order to create the user and group, we will use the power of extensions.

Guix contains a large number of services out of the box; one of them is the account-service-type. This service is used to create users and groups on our operating system.

In order to use that service, we will need to add it to the extensions field of our caddy-service-type.

The extensions field is a bit hard to grasp at first. My first instinct was that the extensions field allows you to modify your service by extending its own capability, giving it extra functionality. For example, in this case, I expected that extending the account-service-type would add the capability to create users and groups to our caddy-service-type.

However it is the opposite! You don't "add" capability to your service, you modify the target service (account-service-type here) to perform actions for your service. How the target service-type is modified is defined by the rules in its compose and extend fields. We'll go over them in more details further below.

For now, let's continue on our account creation to illustrate this concept. We want to create a user, caddy, and a group with the same name, caddy.

The account-service-type is defined as extendable. This means that it offers an interface for other services to create user accounts. The account-service-type doesn't need to know who is creating accounts and why; it only exposes a way to do so.

This is the beauty of this architecture: it makes the system completely declarative. When a service extends the account-service-type, then Guix will create the accounts when the service is enabled. If the service is not enabled, those accounts aren't created.

It's a fantastic architecture when you think about it, it reminds me of the principle of Inversion of Control.

In order to instruct the account-service-type to create our caddy user when the caddy-service-type is enabled, we extend the account-service-type.

We now understand the concept of the extensions field. It allows you to 'extend' a target service-type to, for example, create more users. But we still don't really know how to specify it in practice.

We have a few ways of finding out set it up: reading the docs, grepping examples, or looking at the source.

For the sake of getting better at understanding services, let's look at the source.

Deeper dive: extend and compose

Being curious and eager to really assimilate how services extensions work, I tried find out if we can guess the shape of the accounts by looking at the account-service-type service, defined in shadow.scm:547.

This is how the account-service-type is defined. We should be familiar with the <service-type> record structure.

(define account-service-type
  (service-type (name 'account)
    ;; Concatenate <user-account>, <user-group>, and skeleton
    ;; lists.
    (compose concatenate)
    (extend append)
    (extensions
      (list (service-extension activation-service-type
              account-activation)
        (service-extension shepherd-root-service-type
          account-shepherd-service)
        ;; Have 'user-processes' depend on 'user-homes' so that
        ;; daemons start after their home directory has been
        ;; created.
        (service-extension user-processes-service-type
          (const '(user-homes)))
        (service-extension etc-service-type
          etc-files)))
    (default-value '())
    (description
      "Ensure the specified user accounts and groups exist, as well
as each account home directory.")))

The first thing we can see, is that the default-value is an empty list, which means that the account-service-type itself is expecting a list as a value. But a list of what?

In this case, the comments give us the answer: a list of <user-account> and <user-group>. If it was not for the comments, you could look at the account-activation.

Before moving on, let's talk about compose and extend fields. This is how they are defined in the documentation

> compose

This is the procedure to compose the list of extensions to services of this type.

> extend

This procedure defines how the value of the service is extended with the composition of the extensions.

This is a bit vague and left me a bit scratching my head, but what it means is that:

Compose defines how to the service composes multiple services extending this service-type.

For example,if we have three services listing accounts-service-type as an extension, how do we handle each value? Do we only take the first? The last?

Obviously, if three services are defining users by extending the account-service-type, we want to create all those users. Therefore, we want to concatenate the values provided by the extending services.

We can imagine other services behaving differently. For example, let's imagine a service whose role is to manage a port. Let's call it open-port-22-service-type. Let's also imagine that two services extend this service: one wants to open the port, the other close it.

What shall we do? Open it, or close it? We have conflicting values.

Maybe we want to err on the caution side and define open-port-22-service-type to prioritise 'close' values if it receives contradicting values.

That's what the compose field is for. It defines how to compose multiple extending service values.
Extend defines how the composition from the compose field interact with the service's value itself.

It is, in a way, quite similar to compose

Let's imagine a service-type which displays a welcome message when the computer boots, called welcome-message-service-type. If a service extends it with a different message, we might want to give priority to the extending service value.

In this case, we would use extend to instruct the welcome-message-service-type to replace its own value with the composed values from the extending services.

Note that compose and extend accept procedures which takes the service itself as an argument. It gives the user a lot of freedom and power when defining the rules.

Let's finish with the user-account-service-type as a final example.

In the case of users, we want to:

compose: concatenate the values to create all the users and groups received.
extend: append to the service value. so we create all the users and groups received AND the ones specified by the user-account-service-type service itself (remember that we can instantiate the service with a value).

Zooming back to the architecture, we can see that services are all built upon each other. A service, when installed, will modify the services listed in its extensions field. Those will in turn modify the service-type of their own extensions.

This "chain reaction" will continue until all services are collected in the system-service-type, which is the root of all services. Under the hood, we end up with a collection of all our services in one, large, single structure. I assume that this is conglomerate of services is then handled by Guix when configuring the system.

Ok, we now know the account-service-type:

Accept a list of <user-account> and <user-group> records
Concatenate any values received as per its compose rule.
Append the (concatenated) received values to its own value, as per the extend rule.

Back to our <user-account> and <group-account>

So, by either following in my 'deep dive', reading the documentation or looking up examples in the code base, we found out that our group and user are defined as a <user-account> and <user-group> respectively.

Both records can be found in accounts.scm at line 71 and 90 respectively.

We define our accounts like so:

(define %caddy-accounts
  (list (user-account
          (name "caddy")
          (group "caddy")
          (comment "Run the caddy daemon")
          (system? #t)) ;;<-- the caddy user is a system user, not a real user
    (user-group
      (name "caddy")
      (system? #t))))

Now we can add them the account-service-type extension.

The extensions procedure accepts a list of <service-extension>. A service-extension is a record that accept two parameters.

The first is the name of the target service-type . This is account-service-type in our case. The second parameter to a service-extension is a procedure that takes the service itself (the current caddy service) and returns a list of object to extend the target service (see documentation).

The second parameter seems complicated, but it's simply a procedure that returns the "value" for the extension. In our case, a list of user and group account. You can imagine that using this second argument, we could create the user dynamically based on the value of our caddy-service-type if we wanted make our service configurable. That's how configurable services are structured.

Let's define our service-extension for the account-service-type and add it to the extension field.

(define caddy-service-type
  (service-type
    (name 'caddy)
    (extensions (list (service-extension account-service-type
                        (const %caddy-accounts))))
    (description "Caddy is an extensible server platform that uses TLS by default.")))

We used const here, which is the syntactic sugar for (lambda(_)(%caddy-accounts)).

Alright, time to finally test it out!

Run sudo guix system reconfigure config.scm to apply our changes.

Let's check the presence of the caddy user by running sudo id caddy.

> sudo id caddy
# uid=982(caddy) gid=976(caddy) groups=976(caddy)

Nice! Our caddy user and group were created!

What we have learned so far:

Services are 'things' that modify the system.
Services can be extended and can extend other services.
Services define how they can be extended, via the compose and extend fields.
Services define the service they extend, via the extensions field.
All services are eventually "collected" in the system-service-type, the root service.
We have learned to how to extend the account-service-type to create a user and a group for our service.
We have also learned to dig around the source code to learn more about services.

Now let's see how we can write the config, the Caddy file, into /etc/caddy.

3. Copy the caddy configuration file to the right location

In order to keep matters simple, the caddy-service-type will be static. We will write the Caddyfile manually and provide it to our Caddy service. We won't be in charge of generating the Caddyfile².

The Caddy service will simply be in charge of copying it to the right location.

The target location for Caddyfile is /etc/caddy/caddy.conf.

As before, we will be leveraging extensions to do so. To execute an arbitrary procedure when a service is enabled, we can use the activation-service-type.

Note that there is a service doing exactly this task, the etc-service-type. However I believe that using the more general activation-service-type for didactic purpose is a better choice. It's a widely used service; a lot of the service in the Guix repository rely on it.

The activation service is a service that is executed at activation of our service.

Interestingly enough, I couldn't find much about it in the documentation, except in this example. Let's look at the source code instead.

In services.scm:792 we get a bit more information:

>  ;; The activation service produces the activation script from the gexps it
;; receives.

We can also look at its definition services.scm:776

(define activation-service-type
  (service-type (name 'activate)
    (extensions
      (list (service-extension boot-service-type
              gexps->activation-gexp)
        (service-extension system-service-type
          activation-profile-entry)))
    (compose identity)
    (extend second-argument)
    (default-value #f)
    (description
      "Run @dfn{activation} code at boot time and upon
@command{guix system reconfigure} completion.")))

Alright, we see (from the comment and the lambda gexps->activation-gexp) that the value required by a service is a G-Expression or gexp

What is a gexp? A gexp, or g-exp, or G-expression³ is a Guix of staging code to be executed later in the build environment.

If you know what a G-expression is, you can skip the next section. If not, let's briefly introduce the concept of G-expression⁴.

Shallow dive: G-exps

I won't go to deep into the concept of G-exps; there is a lot to cover and it merits its own article. We will keep a high level overview.

To understand what G-expression are, you need to know that Guix runs in two environments.

When building packages, the guix daemon creates something akin to containers. They aren't quite containers, but the concept is close enough for our understanding.

To ensure reproducibility, each package is built in its own "container", which only includes the required inputs. For this to happen, part of the code in package definition needs to be staged for later execution, inside that "container". G-expressions is how we staging code to be executed at build time.

The two environments of Guix are often referred as:

The "host" environment, in which we define packages and configurations (what we are doing here).
The "build" environment, in which the Guix daemon is performing the actual build actions inside the "container".

G-expressions are expressed with the #~ macro, such as #~( ;; this is a g-expression ;; ). Whenever you see the macro #~, it means that the code inside the bracket will be executed later, inside the build "container".

Inside a G-exp, we can evaluate some expressions using the #$ macro, or ungexp.

For example, let's have a look at this G-expression:

#~(begin
    (mkdir #$output)
    (mkdir "/another/folder/path"))

In this instance, when the code is evaluated #$output will be replaced (or ungexp) and the expression will be:

#~(begin
    (mkdir "/the/output/dir")
    (mkdir "/another/folder/path"))

In concept, it's similar to the quasi-quote and comma in Scheme.

As the G-expression is evaluated in a different environment, it will not have automatically access to the modules imported in the current environment. In order to give the G-expression access to modules, we need to import them in the "build" environment in which the G-expression will be evaluated.

To do so, we use the with-imported-modules syntax like so:

(with-imported-modules '((guix build utils))
  #~(begin
      (use-modules (guix build utils))
      (mkdir-p "/the/output/dir") ;;mkdir-p is a utility found in guix build utils.
      (mkdir-p "/another/folder/path")))

In the example above, mkdir-p is a procedure from in guix/build/utils.scm. The with-imported-modules provides the modules to the G-expression environment. We can then use the standard use-modules syntax as we would in a normal Scheme environment.

There is a lot more to G-expressions, but it merits its own article so I won't go any further.

This is all we need to know at this stage:

G-expression is code staged to be executed in the "build" phase of Guix.
G-expression are written with the #~ macro.
We can ungexp part of the G-expression with the #$ macro.
We can import modules into the G-expression with the with-imported-modules syntax.

If you want to dig deeper, some excellent resources are:

G-Expressions in the documentation
FOSDEM Talk about G-exps (video)
Code Staging in GNU Guix (paper, but very accessible)

Back to the activation service

With this newly acquired knowledge, let's think about what we are trying to achieve here.

We want to:

Create the /etc/caddy directory.
Copy the configuration file at /etc/caddy/caddyfile.
Ensure that the configuration file is read-only for the caddy user.

We need to express those three instructions in a G-expression that we will pass as an argument to the service-extension for the activation-service-type.

This is how we can do so:

(define %caddyfile (plain-file "CaddyFile" ":8080 { respond \"Hello world!\"}"))
;; Generate a plain caddyfile configuration.
;; Refer to https://caddyserver.com/docs/caddyfile-tutorial for more information

(define (%caddy-activation _)
  (with-imported-modules '((guix build utils)) ;; we need some utilities, such as `mkdir-p
    #~(begin
        (use-modules (guix build utils))
        (mkdir-p "/etc/caddy") ;; 1. Create the directory
        (copy-file #$%caddyfile "/etc/caddy/caddyfile") ;; 2. Copy the configuration file at the right location (notice the ungexp!).
        (chown "/etc/caddy/caddyfile"
          (passwd:uid (getpwnam "root")) ;; 3. Change the ownership to root:caddy.
          (group:gid (getgrnam "caddy")))
        (chmod "/etc/caddy/caddyfile" 750)))) ;; 4. Set permissions.

You notice that the %caddy-activation procedure accepts an argument. As discussed earlier, it can receive the current service as an argument, allowing you to dynamically modify the output. For example, you could imagine giving the caddy-service-type the ability to configure the caddy username.

Ok, let's try it out:

(define caddy-service-type
  (service-type
    (name 'caddy)
    (description "Run Caddy, the simple proxy server.")
    (extensions
      (list (service-extension account-service-type (const %caddy-accounts))
        (service-extension activation-service-type %caddy-activation) ;; <- Adding the extension here.
        (default-value nil)))

Now run sudo guix system reconfigure config.scm.

Inspect the content of /etc/caddy/caddyfile:

> sudo cat /etc/caddy/caddyfile
# :8080 { respond "Hello world!"}

Great, we now have our user and our configuration file. We can test out our service by starting caddy manually.

sudo caddy -c /etc/caddy/caddyfile" # you need sudo here, we will resolve this in part 4.

In a second terminal, run curl localhost:8080. You should obtain the response "Hello world!".

We now have successfully created a service to run caddy!

This concludes the configuration of our service. Our service:

creates the daemon user and group.
generate the caddy configuration file
copy it to the right location.

The last part is about making it run as a daemon managed by Shepherd in the background, so we don't need to start it manually.

4. Configure shepherd to run the service in the background (shepherd service).

We now have a working Caddy service. The last remaining part to this guide is to modify our service to instruct Shepherd to run it in the background.

We should by now have a hunch of what needs to be done: we need to extend the Shepherd service.

Before we do this, we need to do a final detour and talk about privileged ports.

Privileged users and privileged programs

On most linux distributions, including Guix, any port numbers below 1024 are special: standard users are not allowed to bind process to them.

Since our caddy user is not a privileged user, it won't be able to run the Caddy server on port 80 (http) and 443 (https). We need to allow the Caddy process to be run on those ports.

The way to go about this in Guix is to use privileged programs.

To make Caddy a privilived program, we append it to the %default-privileged-programs and assign it the necessary extra capabilities.

(privileged-programs
  (append (list (privileged-program
                  (program (file-append caddy "/bin/caddy"))
                  (capabilities "cap_net_bind_service=ep")))
    %default-privileged-programs))

If you're extra curious, you can take a peek at the list of privileged-programs in system.scm:1267. It contains a lot of well known utility requiring extra privileges, such as sudo, su, passwd, ping or mount.

Here, we are adding the capability CAP_NET_BIND_SERVICE as described in man 7 capabilities as Bind a socket to Internet domain privileged ports (port numbers less than 1024).

The =ep means that capability is *e*ffective and *p*ermitted, essentially giving it the capability there and then.

An important thing to note: when we make a program privileged, it is relocated outside of the store. The store cannot contain privileged for security concerns, you can read more about it here. The privileged programs are located in /run/privileged.

Our 'privilged'Caddy program is located at /run/privileged/bin/caddy.

Configuring Shepherd

The next step is to configure Shepherd. To do so, we need to extend the shepherd-root-service-type with a shepherd-service record.

In this case, I won't go into too much detail. The Shepherd service documentation is very helpful and detailed, I highly recommend you to read it. In particular the page about the page about service constructor and destructors explains the role of make-forkexec-constructor and make-kill-desstructor, both doing a lot of the heavy lifting here.

Instead, I will comment the intentions on the extension itself:

(define (%caddy-shepherd-service _)                                 ;; We ignore the config argument as we will not use it.
  (list (shepherd-service
          (provision '(caddy))                                      ;; this is purely an arbitrary naming handle.
          (documentation "Run the caddy daemon")                    ;; self explanatory
          (requirement '(networking user-processes))                ;; We instruct shepherd to start the caddy daemon after the networking and user modules.
          (start #~(make-forkexec-constructor                       ;; the command to start the process: note the use of g-exps! Refer to the doc for an exhaustive list of options
                     (list "/run/privileged/bin/caddy"               ;; Note the location of our privileged version of caddy. The "run" commands and its arguments are Caddy related; refer to the caddy documentation
                       "run" "--config" "/etc/caddy/caddyfile"
                       "--adapter" "caddyfile")
                     #:user "caddy"                                  ;; The user and group in charge of the daemon
                     #:group "caddy"
                     #:log-file "/var/log/caddy.log"
                     #:environment-variables                         ;; Required for the logs
                     '("HOME=/var/lib/caddy")))
          (stop #~(make-kill-destructor)))))                        ;; The destructor, called when the process is killed. Refer to the documentation

A few point worth mentioning:

'user-processes is a requirement for most shepherd-service as mentioned in the documentation. We need the file systems for the user to be mounted before starting Caddy.
'networking is also set as a requirement, we want the network stack up before we start caddy. I found this while looking at how the exim service was written. As far as I can tell, these aren't documented. You will need to look directly in the source code.
I don't quite recall why I set up the environment variable, but I believe it was a requirement for the logs. The service would otherwise it would complain. It is mentionned in the Caddy documentation when using systemctl.

Final code

This is how our entire service looks like:

(use-modules (gnu)
  (guix packages)
  (guix utils)
  (guix download)
  (guix licenses)
  (guix gexp)
  ;;; Redacted ... many modules
  )

(use-service-modules
  ;; Redacted... many modules
  desktop
  networking)

;; Our caddy package, as seen in a previous article
(define caddy
  (package
    (name "caddy")
    (version "2.11.4")
    (source (origin
              (method url-fetch)
              (uri (string-append
                     "https://github.com/caddyserver/caddy/releases/download/v"
                     version "/caddy_" version "_linux_amd64.tar.gz"))
              (sha256
                (base32 "1fbvxj6mifdqhwm5s1f8snr805k0anllzlri7cg9l61rgj8vyzsj"))))
    (build-system copy-build-system)
    (arguments
      (list #:install-plan #~'(("caddy" "bin/"))))
    (home-page "https://caddyserver.com")
    (synopsis "Web server with automatic HTTPS")
    (description "Caddy is an extensible web server with automatic TLS.")
    (license asl2.0)))

;; Our caddy user:group for the daemon
(define %caddy-accounts
  (list (user-account
          (name "caddy")
          (group "caddy")
          (system? #t)
          (comment "Caddy daemon user")
          (home-directory "/var/lib/caddy")
          (create-home-directory? #t)
          (shell (file-append shadow "/sbin/nologin")))
    (user-group
      (name "caddy")
      (system? #t))))

;; Our Caddyfile
(define %caddyfile
  (plain-file "Caddyfile"
    "aloysberger.com {
       root * /srv/http/blog
       file_server
     }
     :8080 {
        respond \"Hello, World!\"
     }")) ;; There is more to my Caddyfile, but yes, it serves this blog!

;; The activation to copy the Caddy file
(define (%caddy-activation _)
  (with-imported-modules '((guix build utils))
    #~(begin
        (use-modules (guix build utils))
        (mkdir-p "/etc/caddy")
        (copy-file #$%caddyfile "/etc/caddy/caddyfile")
        (chown "/etc/caddy/caddyfile"
          (passwd:uid (getpwnam "root"))
          (group:gid (getgrnam "caddy")))
        (chmod "/etc/caddy/caddyfile" 750))))

;; The Shepherd definition for our Caddy daemon
(define (%caddy-shepherd-service _)
  (list (shepherd-service
          (provision '(caddy))
          (documentation "Run the caddy daemon")
          (requirement '(networking))
          (start #~(make-forkexec-constructor
                     (list "/run/privileged/bin/caddy"
                       "run" "--config" "/etc/caddy/caddyfile"
                       "--adapter" "caddyfile")
                     #:user "caddy"
                     #:group "caddy"
                     #:log-file "/var/log/caddy.log"
                     #:environment-variables
                     '("HOME=/var/lib/caddy")))
          (stop #~(make-kill-destructor)))))

;; And finally, the entire service
(define caddy-service-type
  (service-type
    (name 'caddy)
    (description "Run Caddy, the simple proxy server.")
    (extensions
      (list (service-extension account-service-type (const %caddy-accounts))
        (service-extension activation-service-type %caddy-activation)
        (service-extension shepherd-root-service-type %caddy-shepherd-service)))
    (default-value #t)))

(operating-system
  (locale "en_AU.utf8")
  (timezone "Australia/Brisbane")
  (keyboard-layout (keyboard-layout "au"))
  (host-name "[REDACTED]")
  (users (cons* (user-account
                  ;; [REDACTED - Users are defined here
                  %base-user-accounts))
    ;; Elevating Caddy's privilege to bind to port under 1024.
    (privileged-programs
      (append (list (privileged-program
                      (program (file-append caddy "/bin/caddy"))
                      (capabilities "cap_net_bind_service=ep")))
        %default-privileged-programs))

    (services
      (append (list (service ;; [REDACTED] Many services here: SSH, paperless, mail...
                      (service caddy-service-type) ;; <-- Our Caddy service!
                      %base-services))
        (bootloader (bootloader-configuration
                      (bootloader grub-bootloader)
                      (targets (list "[REDACTED]"))
                      (keyboard-layout keyboard-layout)))
        (swap-devices (list (swap-space
                              (target (uuid "[REDACTED")))))

Alright, time to start it: sudo guix system reconfigure config.scm

Once started, we can check the health of our daemon using the herd command: sudo herd status caddy.

You should see something like so:

Status of caddy:
It is running since Wed Jul  8 18:06:04 2026 (41 days ago).
Main PID: 17241
Command: /run/privileged/bin/caddy run --config /etc/caddy/caddyfile --adapter caddyfile
It is enabled.
Provides: caddy
Requires: networking
Replacement pending (restart to upgrade).
Will be respawned.
Log file: /var/log/caddy.log

Let's verify it works:

> curl localhost:8080
# Hello, World!

Nice. Our service is working and the process is running in the background, managed by Shepherd.

How to modify the Caddyfile

If you wish to change the Caddyfile, you can modify our %caddyfile and reconfigure the system. Alternatively, for quick debugging purpose, you can modify the file directly at /etc/caddy/caddyfile and restart the caddy server with sudo herd restart caddy.

Conclusion

If you have read thus far, thank you!

As a summary, let's review what we have covered:

Guix services and the extensions architecture.
executing an arbitrary command when enabling a service (activation-service-type).
creating and managing users declaratively (user-account-service-type).
a (quick!) primer on G-expressions.
elevating program privileges with privileged-programs,
running a service as a daemon in the background using Shepherd (shepherd-service-type).

As stated in the title, I am not an expert in Guix or Scheme. I stumbled my way through this creating this service; and it probably show! In any case, I hope that it will help you getting start with custom services and that it clarified some concepts around services.

I am sure there are improvements to be made, such as using the etc-service-type instead of the activation-service-type. If you have any comments, please kindly send them to contact@aloysberger.com.

I hope you enjoyed this article.

Footnotes:

Not available yet, but I did see a PR a couple of months ago, so it might already be available.

in the future, I want to write a small DSL to generate the caddy config file in a declarative matter.

unsure what is the convention here? I have seen all three

⁴

We won't do a deep dive into G-exps, there is enough to warrant its own article

Book review: Sapiens by Yuval Noah Harari.

2026-08-17T19:38:00Z

Sapiens appears on many book recommendation lists, and I now understand why.

The author, Yuval Noah Harari, gives you a brief commented history of humankind. He explains how, as a specie, we arrived to where we are today and why we think the way we do¹.

In each chapter, Yuval introduce and discuss an aspect of humanity, in a chronological order. For example, the birth of money, the difference between chimpanzee and us or the role of the state in the community. He remains very open on all subjects, often presenting a compelling idea followed by a counter argument as strong as the idea itself.

At first, it seemed like the author doesn't want to give his opinion. However, I believe the goal is to invite the reader to think and reflect on the idea; which he successfully did with me.

The book has more value in what is not written, rather than what is written.

Sapiens will remain a staple on my bookshelf; I'm not very knowledgeable when it comes to history and anthropology: Sapiens was an excellent primer to both areas.

I highly recommend it.

I especially enjoyed the later chapters on the last four centuries, from the rise of science in Europe to the birth of capitalism and how it shaped the world as we know it today.

The second to last chapter on happiness was also a pleasant surprise. I did not expect it in this book. It is a subject I am curious about, and the content in the twenty or so pages about happiness were very thought-provoking.

Interestingly, the book was written in 2014 the last chapter is already feeling a tad obsolete² as it praise how stable and peaceful the world has been in the last decade.

Footnotes:

At least, in the western world.

for worse, unfortunately

Finished reading "Sapiens" by Yuval Noah Harari

2026-08-17T11:36:00Z

I will write a short review shortly, but I understand why this often comes as a highly recommended book. It contains a lot of intriguing ideas, and challenge some widely accepted view on humanity.