NixOS Guix

Yes — NixOS does use systemd by default.

Key points

• Init system: systemd
• Service manager: systemd
• Targets / units: standard systemd units (services, timers, sockets, etc.)

NixOS integrates systemd deeply, but configures it declaratively via Nix instead of imperative commands.

How NixOS uses systemd (what’s different)

You don’t usually write unit files by hand. Instead, you define services in configuration.nix, and NixOS generates the systemd units for you.

Example:

services.nginx.enable = true;

This automatically creates and manages:

• nginx.service
• dependencies
• users/groups
• config files

You can still interact with systemd normally:

systemctl status nginx
systemctl restart nginx
journalctl -u nginx

Custom systemd services in NixOS

You can define your own units declaratively:

systemd.services.my-service = {
  description = "My custom service";
  wantedBy = [ "multi-user.target" ];
  serviceConfig = {
    ExecStart = "/path/to/binary";
    Restart = "always";
  };
};

Can NixOS run without systemd?

• Officially: no
• Practically: systemd is required for standard NixOS
• Experimental alternatives exist (e.g. OpenRC), but they are unsupported and incomplete

If you want:

• ❌ no systemd → use Void Linux, Artix, or Gentoo
• ✔ declarative + systemd → NixOS

Summary

If you want, I can compare NixOS vs Arch vs Gentoo vs Void from a system-design perspective.

Yes — Guix is very similar to NixOS in philosophy, but different in important technical choices.

Short answer first:

GNU Guix System does NOT use systemd.

Guix vs NixOS — the big picture

What Guix uses instead of systemd

🐑 GNU Shepherd

• Init system written in Guile (Scheme)
• Older name: dmd
• Much simpler than systemd
• Focused only on service management

Key characteristics:

• No PID 1 feature creep
• No journal replacement
• No device manager
• No login manager
• No tight coupling with everything

Shepherd is closer to:

• runit
• s6
• OpenRC than to systemd.

Example: defining a service in Guix

(service nginx-service-type
         (nginx-configuration
           (server-blocks
             (list
               (nginx-server-configuration
                 (server-name '("example.com"))
                 (listen '("80"))))))

This generates:

• service definition
• dependency graph
• start/stop logic

No unit files.

Can Guix use systemd?

• ❌ No
• systemd is intentionally avoided
• Guix aligns with FSF principles (systemd is considered non-GNU)

Similarities with NixOS

They share the same core ideas:

• Declarative OS configuration
• Functional package management
• Immutable store (/gnu/store vs /nix/store)
• Atomic upgrades
• Rollbacks
• Profiles and generations

They solve the same problems, but with different ideology.

Major differences (practical)

Language

• NixOS: custom DSL (quirky)
• Guix: full Scheme (powerful, consistent)

Boot speed

• Guix + Shepherd is usually faster than systemd

Hardware support

• NixOS: broader, more practical
• Guix: more limited (especially firmware)

Ecosystem

• NixOS: much larger
• Guix: smaller, cleaner

Who should choose Guix?

Choose Guix if you want:

• No systemd
• 100% free software (or close)
• Scheme-based config
• Minimalism
• FSF-aligned system

Choose NixOS if you want:

• Best hardware support
• systemd integration
• Huge package ecosystem
• More “plug-and-play”

TL;DR

• ✅ Guix ≈ NixOS philosophically
• ❌ Guix ≠ systemd
• 🐑 Guix uses GNU Shepherd
• 🧠 Same idea, different ideology

If you want, I can help you decide Guix vs NixOS vs Artix vs Void based on how you actually use your machine.

Yes — but with important caveats. GNU Guix is FSF-pure by default, so it avoids non-free firmware, yet you can install non-free blobs manually if you really need them (like for Wi-Fi).

Here’s a breakdown.

1️⃣ What Guix provides out of the box

• Only free firmware is included (mostly for some Intel or open Broadcom chips).
• Most Wi-Fi requiring proprietary firmware (Broadcom, Realtek) is not included.
• System won’t load non-free blobs automatically — FSF policy.

2️⃣ Ways to get non-free firmware on Guix

Option A — Use Guix operating-system config hooks

You can copy firmware to /etc/firmware or /lib/firmware and load it via kernel modules.

Example:

(operating-system
  ;; ...
  (file-systems
    (cons* (file-system
             (mount-point "/lib/firmware")
             (device #f)
             (type "tmpfs")
             (options '("mode=755")))
           %base-file-systems))
  ;; Hook to copy firmware
  (packages (append
             (list (local-file "path/to/your/firmware/driver.bin"))
             %base-packages)))

Then the kernel module can pick it up.

Option B — Use Guix’s --substitute-binary feature

Guix allows binary substitution for packages that are not in FSF repo. This is advanced; usually involves:

1. Downloading precompiled firmware blobs
2. Importing them as local-package definitions
3. Adding them to your system profile

Option C — Dual-boot / hybrid approach

Some users:

• Boot Guix on free firmware hardware
• Or use a USB stick with non-free firmware preloaded
• Then Guix sees the device as working

3️⃣ Wi-Fi specifics

• Broadcom chips: almost always need non-free b43 or wl firmware
• Realtek: often need rtlwifi blobs
• Intel: mostly free, works out of the box

Check with:

lspci -nnk | grep -iA3 net

4️⃣ Caveats

• Installing non-free firmware breaks FSF purity
• Updates may not be smooth, you may need to manually re-copy blobs on kernel updates
• Guix community generally recommends Intel or Atheros cards for 100% free experience

✅ TL;DR

• Guix doesn’t include non-free Wi-Fi firmware by default.
• You can install it manually (copy blobs + kernel modules).
• If you want FSF-pure, use Intel/Atheros Wi-Fi.
• If you need Broadcom/Realtek, you need manual intervention.

If you want, I can give you a step-by-step example to make a Broadcom Wi-Fi chip fully work on Guix, including config snippets. Do you want me to do that?

Perfect! Let’s go step by step for getting a non-free Wi-Fi driver working on Guix System. I’ll make it clear, declarative where possible, while keeping it practical.

We’ll assume your Wi-Fi card requires a proprietary firmware blob (like Broadcom or some Realtek chips).

1️⃣ Identify your Wi-Fi card

Open a terminal:

lspci -nnk | grep -iA3 net

Output example:

03:00.0 Network controller [0280]: Broadcom Inc. and subsidiaries BCM43142 802.11b/g/n [14e4:4365]
        Subsystem: Hewlett-Packard Company BCM43142 802.11b/g/n
        Kernel driver in use: wl

✅ Note:

• 14e4:4365 → PCI ID
• Kernel driver in use may show b43 or wl
• You need a firmware blob that matches your card

2️⃣ Get the proprietary firmware

• Go to the manufacturer site or trusted repository (Broadcom, Realtek, etc.)
• For Broadcom BCM43142: get wl_apsta.o (or .bin) firmware
• Save it to a folder, e.g.:

mkdir -p ~/firmware
cp wl_apsta.o ~/firmware/

3️⃣ Copy firmware to /lib/firmware

Guix expects firmware in /lib/firmware (or a subdirectory used by the kernel module):

sudo cp ~/firmware/* /lib/firmware/

4️⃣ Load the kernel module

For Broadcom, for example:

sudo modprobe wl

Check your Wi-Fi interface:

ip link

You should see wlan0 or similar.

5️⃣ Make it persistent (declarative approach)

Guix lets you include local packages in your system configuration. Create a local package for the firmware:

a) Create a folder for local packages:

mkdir -p ~/guix-packages

b) Define a local package firmware-broadcom.scm:

(use-modules (guix packages)
             (guix download)
             (guix build-system trivial)
             (guix licenses))

(define-public firmware-broadcom
  (package
    (name "firmware-broadcom")
    (version "1.0")
    (source (local-file "/home/username/firmware/wl_apsta.o"))
    (build-system trivial-build-system)
    (arguments `(#:install-file (("wl_apsta.o" "share/firmware/wl_apsta.o"))))
    (home-page "https://www.broadcom.com")
    (synopsis "Proprietary Broadcom Wi-Fi firmware")
    (description "Firmware blob for Broadcom Wi-Fi chips")
    (license non-free)))

c) Add to your system configuration

Edit /etc/config.scm (or wherever your operating-system block is):

(operating-system
  ;; ...
  (packages
   (append
    (list (local-package "firmware-broadcom" "~/guix-packages/firmware-broadcom.scm"))
    %base-packages))
)

d) Rebuild system

sudo guix system reconfigure /etc/config.scm

✅ This will:

• Copy the firmware to /gnu/store/.../share/firmware/...
• Make it part of your system declaratively
• Rollback possible if anything breaks

6️⃣ Load module on boot

Add the kernel module to operating-system:

(operating-system
  ;; ...
  (linux-modules (cons "wl" %base-linux-modules))
)

Reconfigure again:

sudo guix system reconfigure /etc/config.scm

Now your non-free Wi-Fi driver is persistent and declarative.

7️⃣ Connect to Wi-Fi

You can use NetworkManager:

sudo systemctl start NetworkManager
nmcli device wifi list
nmcli device wifi connect "SSID_NAME" password "YOUR_PASSWORD"

✅ Summary

1. Identify Wi-Fi chip with lspci.
2. Download the proprietary firmware blob.
3. Copy it to /lib/firmware for immediate testing.
4. Load the kernel module manually (modprobe wl).
5. Wrap firmware as a local package in Guix.
6. Add package and kernel module to operating-system declaratively.
7. Reconfigure with guix system reconfigure.
8. Connect via NetworkManager.

If you want, I can make a ready-to-paste Guix snippet for Broadcom and Realtek chips so you can just drop it in your config and rebuild — fully declarative.

Do you want me to do that?