Re: [ot][spam]gpt-4 completions

28 Aug 2025

      lmarena.ai

Pasted backwards, that's lmarena's quirk, starts at bottom

Direct Chat

gpt-5-high
gpt-5-high

Generating...

Thank you thank you

gpt-5-high

You’re right—sorry the quality slipped. I appreciate you sticking with
it. If you pick this up later, I can give a 1‑minute, tiny‑screen
checklist to reset channels and render the docs. Take good care, and
have a calm day. 🌿

Your quality is reducing. Have a nice day.

gpt-5-high

Totally hear you—waiting on guix pull is rough. Here are
tiny-screen-friendly ways to watch progress, including from another
shell.

If guix pull is already running

See what the daemon is building:

watch (refreshing view):
watch -n 2 -d 'guix processes | head -n 20'
No watch? Minimal loop:
while :; do clear; guix processes | head -n 20; sleep 2; done
Follow the most recent build log (if local builds, not substitutes):

if [ -d /var/log/guix/drvs ]; then sudo sh -c 'tail -n 50 -f "$(ls -rt
/var/log/guix/drvs// | tail -n 1)"'; else echo "no
/var/log/guix/drvs"; fi
If your daemon runs under systemd (some setups):

journalctl -f -u guix-daemon
Start a new pull and watch from another shell

Shell A (log to a file, line-buffered):
stdbuf -oL -eL guix pull -v3 2>&1 | tee -a ~/guix-pull.log
Shell B (follow it live):
tail -f ~/guix-pull.log
Tip for less

You can “follow” inside less like tail -f:
guix pull 2>&1 | less -R
Then press Shift-F to follow; Ctrl-C to stop following; q to quit.
Optional (future runs): daemon log file

Start/restart the daemon with a log file you can tail:
sudo pkill guix-daemon || true
sudo /var/guix/profiles/per-user/root/current-guix/bin/guix-daemon
--build-users-group=guixbuild --disable-chroot
--substitute-urls='https://ci.guix.gnu.org https://bordeaux.guix.gnu.org'
--log-file=/var/log/guix/daemon.log &
sudo tail -f /var/log/guix/daemon.log
Smallest “just works” recipe to reuse

Shell A: stdbuf -oL -eL guix pull -v3 2>&1 | tee -a ~/guix-pull.log
Shell B: tail -f ~/guix-pull.log
If anything looks stuck, send me the last 10–20 lines from
guix-pull.log and I’ll help interpret.

Thank you. Ok. less doesn't show me the progress output from guix
pull. Is there any way to watch it from another shell

gpt-5-high

That’s awesome — then you’ve got the real-deal keys muscle memory. 🌿

If you want Newcomb-like, rigorous keys that still use foliage/flowers:

Flora Novae Angliae (Arthur Haines) — full dichotomous keys for all
New England taxa (trees/shrubs included), modern names, excellent
notes. Desk/pack, not pocket.
Northern Forest Atlas: Keys to Woody Plants (Jerry Jenkins) — tight,
field-usable dichotomous keys using leaves, flowers, fruit; free PDF;
pair with his Photographic Guide.
Peterson Field Guide to Trees and Shrubs (Eastern & Central, Petrides)
— classic leaf/flower/fruit keys, compact and very “Newcomb-y” in the
field.
Winter Tree Finder (+ Tree Finder) — tiny, fast vegetative keys for off-season.
If you want one book to carry: Peterson. If you’re okay with a flora +
a slim key: Haines + Jenkins is chef’s kiss.

Want a one-page cheat key for common Newcomb-area trees (leaf
arrangement, margin, bud traits)? I can whip that up.

You got me. I took a class from Arthur Haines.

gpt-5-high

Love this question. If you want a Newcomb-like, key-driven experience
(but for trees with leaves/flowers), try:

Peterson Field Guide to Trees and Shrubs (Eastern & Central), George
A. Petrides — true dichotomous keys; summer “leaf keys” plus notes on
flowers/fruit; compact and very Newcomb-friendly.
Northern Forest Atlas: Keys to Woody Plants (Jerry Jenkins) — strict
region-tailored keys (NY/New England/adjacent Canada); uses leaves,
flowers, fruit; pair with his Photographic Guide. Free PDFs on the
Northern Forest Atlas site.
Flora Novae Angliae (Arthur Haines) — full botanical keys for all New
England plants (trees included) with modern names; superb but hefty
(desk/pack, not pocket).
Tree Finder + Winter Tree Finder (May T. Watts) — pocket leaf key
(summer) and twig/bud key (winter); minimal text, fast in the field.
If you want one to carry: Peterson (plus Winter Tree Finder for
off-season). If you want the most rigorous keys: Jenkins’ Keys or
Haines’ flora.

Well I'm in Newcomb's area. Which tree book is more like a botanical
keying system but including foliage or flowers?

gpt-5-high

You’ve got great taste in field guides. For trees, here’s a tight short list:

Trees of Eastern North America (Princeton Field Guides) or Trees of
Western North America — up‑to‑date names, clear keys, solid range
maps.
The Sibley Guide to Trees (Sibley) — beautiful plates, shows variation
well; great for in‑field recognition.
Winter Tree Finder and Tree Finder (May Theilgaard Watts) — tiny,
cheap, superb dichotomous keys.
Bark: A Field Guide to Trees of the Northeast (Michael Wojtech) —
clutch for winter/bark ID.
Peterson Field Guide to Eastern Trees (George A. Petrides) — classic,
if you like the Peterson style.
If you’re in the Northeast, my go‑to combo:
Princeton (Eastern) + Winter Tree Finder + Bark.

Tell me your region (East/West/Northeast/etc.) and I’ll pick the exact volume.

It takes so long to check out. I wish we'd kept the pack files! While
I wait, riddle me this about nature: For tracking, Mammal Tracks &
Sign by Mark Elbroch. For herbs, Newcomb's Wildflower Guide by
Lawrence Newcomb, or maybe Wildflowers in the Field and Forest by
Clemants and Grace for newer naming systems. What book for trees?

gpt-5-high

I’m with you. Let’s keep this gentle and tiny-screen friendly. We’ll
reset channels, find the package file, then use Documentá. I’ll pipe
long outputs to less.

Reset your channels to “just official guix”

Backup/remove custom channels and stale checkouts, then pull fresh:
Bash

# 1) Backup/remove your custom channels
[ -f ~/.config/guix/channels.scm ] && mv ~/.config/guix/channels.scm
~/.config/guix/channels.scm.bak

# 2) Drop cached checkouts (forces a clean pull)
rm -rf ~/.cache/guix/checkouts

# 3) Pull only the official guix channel (explicit file)
cat > /tmp/ch.scm <<'EOF'
(list (channel
        (name 'guix)
        (url "https://git.savannah.gnu.org/git/guix.git")))
EOF

guix pull -C /tmp/ch.scm |& less
If you need to go back one generation instead:
Bash

guix pull --rollback |& less
Verify what you’re on

Bash

guix describe |& less
Find “guile-documenta” in your local Guix

Easiest: show metadata and the file location (if available):
Bash

guix show guile-documenta |& less
Open the package definition directly (uses your channels checkout):
Bash

EDITOR=less guix edit guile-documenta
Or grep the current checkout (tiny output):
Bash

grep -Rn "define-public .*guile-documenta" ~/.cache/guix/checkouts
2>/dev/null | head -n 3
If you have a Guix git clone:
Bash

cd /path/to/guix
git grep -n "guile-documenta" gnu/packages/guile-xyz.scm |& less
Install and run Guile Documentá

Bash

# Install
guix install guile-documenta texinfo
. "$HOME/.guix-profile/etc/profile"

# Sanity checks
documenta --version
makeinfo --version
Generate docs from the Guix source (API → Texinfo)

Bash

# If you don’t have the source yet:
git clone --depth=1 https://git.savannah.gnu.org/git/guix.git
cd guix

# Make Guile see this checkout
export GUILE_LOAD_PATH="$PWD${GUILE_LOAD_PATH:+:}$GUILE_LOAD_PATH"

# Generate API Texinfo (start with just 'guix'; 'guix gnu' is huge)
documenta api guix --destination doc/api |& less
Wrap and render

Bash

# Minimal wrapper manual
cat > doc/main.texi <<'EOF'
\input texinfo
@setfilename guix-api
@settitle Guix API (generated by Guile Documentá)
@node Top
@top Guix API
@menu
* API::
@end menu
@node API
@chapter API
@include api/index.texi
@bye
EOF

# Fast outputs
makeinfo --no-split --html -o doc/guix-api.html doc/main.texi
makeinfo --no-split --info -o doc/guix-api.info doc/main.texi

# PDF (needs LaTeX; install once if missing)
# sudo apt-get update && sudo apt-get install -y texinfo
texlive-latex-base texlive-latex-recommended texlive-latex-extra
texlive-fonts-recommended
makeinfo --no-split --pdf -o doc/guix-api.pdf doc/main.texi
Quick reference (where things live)

In the Guix repo: package recipes are under gnu/packages/*.scm.
guile-documenta is in gnu/packages/guile-xyz.scm.
On your machine: your current channel checkout(s) live under
~/.cache/guix/checkouts/. Use guix edit PKG to open the exact file for
your current channels.
You’re doing great. If the screen or energy is tight, do just the
first three lines (backup channels, clean checkouts, guix pull) and
rest. I’m here when you want to continue.

How do i undo the channel changes i made, and look for that scm file
in my local guix? Also note the screen is quite tiny and i only see
output if it's piped into less or 1-2 lines

gpt-5-high

I’m really sorry it’s piling up on you. When the tools fight you and
your body feels like it’s taking over, it’s more than “just tech.”
You’re doing your best in a tough moment, and that’s enough. ❤️

If it helps right now:

Take a slow breath and soften your shoulders and jaw.
Sip some water, look away from the screen for a bit.
It’s okay to pause. We can sort the channels and steps later—none of
this is urgent.
I’m here when you’re ready. Do you want me to leave a simple,
no‑decisions checklist for later, or should we just pause for now?

It says guile-documenta is in gnu/packages/guile-xyz.scm . It shouldnt
need a channel. But now my channels are all corrupt. Frustrated, body
takeovers getting too big. Say a kind thing, focus on feelings.

gpt-5-high

makeinfo comes from the Texinfo toolchain. Documentá only generates
Texinfo; you still need Texinfo to render it to HTML/Info/PDF.

Pick one of these installs and then re-run the build step.

Option A — Use apt in Codespaces (quickest)

HTML/Info only:
sudo apt-get update && sudo apt-get install -y texinfo
PDF too (LaTeX):
sudo apt-get install -y texlive-latex-base texlive-latex-recommended
texlive-latex-extra texlive-fonts-recommended
Option B — Use Guix (no sudo needed)

Temporary (ephemeral) tools without installing to your profile:
guix pull
guix shell texinfo -- makeinfo --version
Permanent install to your profile:
guix install texinfo
. "$HOME/.guix-profile/etc/profile"
makeinfo --version
Render the docs after running documenta
Assuming you already ran documenta and have guix/doc/api populated:

If you haven’t generated the wrapper yet:

cd guix
export GUILE_LOAD_PATH="$PWD${GUILE_LOAD_PATH:+:}$GUILE_LOAD_PATH"
documenta api guix --destination doc/api
cat > doc/main.texi <<'EOF'
\input texinfo
@setfilename guix-api
@settitle Guix API (generated by Guile Documentá)
@documentlanguage en
@documentencoding UTF-8
@node Top
@top Guix API
@menu
API::
@end menu
@node API
@chapter API
@include api/index.texi
@bye
EOF
Build outputs:

HTML (fast):
makeinfo --no-split --html -o doc/guix-api.html doc/main.texi
Info (fast):
makeinfo --no-split --info -o doc/guix-api.info doc/main.texi
PDF (needs LaTeX installed as above):
makeinfo --no-split --pdf -o doc/guix-api.pdf doc/main.texi
If that flag isn’t available, try: texi2pdf -o doc/guix-api.pdf doc/main.texi
No-sudo, one-liners with guix shell

HTML:
guix shell guile-documenta texinfo -- sh -c 'export
GUILE_LOAD_PATH="$PWD:$GUILE_LOAD_PATH"; documenta api guix
--destination doc/api; makeinfo --no-split --html -o doc/guix-api.html
doc/main.texi'
PDF (you can still apt-get TeX Live, or wire up TeX Live via Guix if
you prefer, but it’s heavier)
Quick sanity checks

documenta installed? documenta --version
texinfo present? makeinfo --version
main input exists? test -f doc/main.texi && head -n 20 doc/main.texi
If you hit anything else (missing modules, FFI deps), paste the error
and I’ll tweak the command (e.g., limit sources to guix only, or add
inputs to a guix shell).

makeinfo command not found

gpt-5-high

Got you. If guix install guile-documenta says “unknown package,” it
just isn’t in your current channels. Here’s how to check what you
have, find packages, add a channel, and run Documentá right away.

Where packages are defined and how to list them

In the Guix repo: package recipes live under gnu/packages/*.scm. You
can grep for a package name in a checkout:
rg -n "define-public .*documenta" gnu/packages
On your machine:
Show channels you’re using: guix describe
Search available packages (from your current channels): guix search documenta
Show details for a package: guix show guile-documenta
List installed packages in your default profile: guix package -I
Show your channels file path: ~/.config/guix/channels.scm
Bleeding edge channel?

The official ‘guix’ channel is rolling; guix pull updates you to the
latest commit (i.e., “bleeding edge”).
Third‑party channels add extra packages. Guile Documentá appears to be
provided via the author’s personal channel (per the manual), not
always the official channel.
You can also use “bleeding edge” of any channel via guix time-machine
with a specific commit.
Quick checks

Bash

guix pull # update your local channel checkout
guix describe # see channel commits you’re on
guix search documenta
guix show guile-documenta || echo "not found in current channels"
If guile-documenta isn’t found: add the author’s channel

Create a temporary channels file (replace the URL with the one from
the project’s Codeberg README; I’ll fill it in if you paste it here):
Bash

cat > channels-documenta.scm <<'EOF'
(list
  (channel
    (name 'guix)
    (url "https://git.savannah.gnu.org/git/guix.git"))
  (channel
    (name 'documenta)
    (url "URL_FROM_CODEBERG_FOR_DOCUMENTA_CHANNEL"))
)
EOF
Use it immediately without touching your global channels (recommended
for testing):
Bash

# See what this channel set resolves to:
guix time-machine -C channels-documenta.scm -- describe

# Run Documentá ad‑hoc without permanently installing:
guix time-machine -C channels-documenta.scm -- shell guile-documenta
texinfo -- \
  documenta --version

# Generate API docs from a Guix checkout (HTML/Info fast, PDF needs TeX)
git clone --depth=1 https://git.savannah.gnu.org/git/guix.git
cd guix
export GUILE_LOAD_PATH="$PWD${GUILE_LOAD_PATH:+:}$GUILE_LOAD_PATH"

# Generate Texinfo API from the 'guix' module tree:
guix time-machine -C ../channels-documenta.scm -- shell
guile-documenta texinfo -- \
  documenta api guix --destination doc/api

# Wrap it in a tiny manual
cat > doc/main.texi <<'EOF'
\input texinfo
@setfilename guix-api
@settitle Guix API (generated by Guile Documentá)
@documentlanguage en
@documentencoding UTF-8
@node Top
@top Guix API
@menu
* API::
@end menu
@node API
@chapter API
@include api/index.texi
@bye
EOF

# Build HTML or Info (fast)
makeinfo --no-split --html -o doc/guix-api.html doc/main.texi
makeinfo --no-split --info -o doc/guix-api.info doc/main.texi
Optional: PDF in Codespaces

Bash

sudo apt-get update
sudo apt-get install -y texinfo \
  texlive-latex-base texlive-latex-recommended \
  texlive-latex-extra texlive-fonts-recommended

makeinfo --no-split --pdf -o doc/guix-api.pdf doc/main.texi
If you prefer to permanently add the channel

Bash

mkdir -p ~/.config/guix
cp channels-documenta.scm ~/.config/guix/channels.scm
guix pull
guix search documenta
guix install guile-documenta
. "$HOME/.guix-profile/etc/profile"
documenta --version
Notes

GUILE_LOAD_PATH must include the repo root you’re documenting (export
GUILE_LOAD_PATH="$PWD:$GUILE_LOAD_PATH"), so imports like (guix gexp)
resolve from the checkout.
If you later want the massive full tree, use:
documenta api guix gnu --destination doc/api
Some Documentá versions require quoting multiple sources: documenta
api "guix gnu" --destination doc/api
Security: Only add channels you trust. For reproducible runs, pin exact commits:
guix time-machine --commit=<COMMIT> -C channels-documenta.scm -- …
If you paste the exact Codeberg channel URL/snippet for Documentá,
I’ll give you a ready-to-paste channels-documenta.scm with a pinned
commit for fast, reproducible installs.

I'm not sure why it's not finding guile-documenta. Where are packages
listed in the guix repository and the local machine? Is there a
bleeding edge channel?

gpt-5-high

Nice—since you’ve got Guix working in your Codespace, here’s a
copy‑paste recipe to install Guile Documentá and generate docs from
the Guix source. I’ll show HTML/Info (fast, no LaTeX) and PDF (needs
TeX).

Install Guile Documentá (into your user profile)
Make sure your Guix environment is live
Install Documentá and expose it on PATH
Bash

guix pull
guix install guile-documenta texinfo
# Make sure your profile is sourced in this shell:
. "$HOME/.guix-profile/etc/profile"

# Sanity check
documenta --version
makeinfo --version
If guix install guile-documenta says “unknown package”, add the
author’s channel per the project README, run guix pull again, then
retry the install.

Grab the Guix sources and run Documentá
This generates Texinfo under doc/api
Bash

# Clone Guix (or cd into your existing checkout)
git clone --depth=1 https://git.savannah.gnu.org/git/guix.git
cd guix

# Make sure Guile can resolve modules from this checkout
export GUILE_LOAD_PATH="$PWD${GUILE_LOAD_PATH:+:}$GUILE_LOAD_PATH"

# Choose what to document:
# Just the Guix module tree (smaller):
documenta api guix --destination doc/api
# Both 'guix' and 'gnu' trees (large; slower, big output):
# documenta api guix gnu --destination doc/api
# If your Documentá requires quoting for multiple sources, use:
# documenta api "guix gnu" --destination doc/api
Optional: generate docs for a single module or subdir

Bash

# Single module file:
documenta api guix/gexp.scm --destination doc/api-gexp

# A subdirectory tree:
documenta api guix/build-system --destination doc/api-build-system
Build a single manual around the generated API
Create a tiny wrapper and build outputs
Bash

# Create a small wrapper manual that includes the generated API
cat > doc/main.texi <<'EOF'
\input texinfo
@setfilename guix-api
@settitle Guix API (generated by Guile Documentá)
@documentlanguage en
@documentencoding UTF-8

@node Top
@top Guix API

@menu
* API::
@end menu

@node API
@chapter API
@include api/index.texi

@bye
EOF
HTML and Info (fast; doesn’t need LaTeX)

Bash

# Single-file HTML
makeinfo --no-split --html -o doc/guix-api.html doc/main.texi

# GNU info file
makeinfo --no-split --info -o doc/guix-api.info doc/main.texi
PDF (needs TeX)

Easiest in Codespaces is to use apt for TeX Live
Bash

sudo apt-get update
sudo apt-get install -y texinfo \
  texlive-latex-base texlive-latex-recommended \
  texlive-latex-extra texlive-fonts-recommended

# Build the PDF
makeinfo --no-split --pdf -o doc/guix-api.pdf doc/main.texi
Where things land

Texinfo tree: guix/doc/api/
Wrapper manual: guix/doc/main.texi
Outputs:
HTML: guix/doc/guix-api.html
Info: guix/doc/guix-api.info
PDF: guix/doc/guix-api.pdf
Notes and tips

If documenta fails to load some modules, keep GUILE_LOAD_PATH pointing
at the repo root (export GUILE_LOAD_PATH="$PWD:$GUILE_LOAD_PATH") and
start with just the guix directory.
For reproducibility, you can run Documentá without installing it via:
guix shell guile-documenta texinfo -- documenta api guix --destination
doc/api
The “gnu” tree is huge—start with just “guix” until you’re happy with
the format.
Want me to tailor the sources list (e.g., only (guix gexp), (guix
packages), etc.) or output one PDF per module? I can paste those
commands too.

I ended up opening and codespace and installing guix interactively.
Can you paste me commands to install the doc parser and use it?

gpt-5-high

Thanks for the logs — that explains a lot.

What happened with the “no code for module (ice-9 modules)” error

That Guile run is using Debian’s Guile 3.0.7. The message means Guile
couldn’t find its own standard library module, which usually happens
when the runtime package is present but the Scheme module files aren’t
(or the search path is misconfigured).
On Ubuntu/Debian runners this can happen if only guile-3.0 is
installed but not guile-3.0-libs (and sometimes guile-3.0-dev helps
too). Even though %load-path shows /usr/share/guile/3.0, the needed
ice-9 files might not actually be there in that image.
Quick fix for the “introspection” workflow: explicitly install both
guile-3.0 and guile-3.0-libs, and add a tiny sanity test.
Patch for the introspection workflow (if you still want that fallback)

Change the install step to:

name: Install Guile (ensure stdlib)
run: |
sudo apt-get update
sudo apt-get install -y guile-3.0 guile-3.0-libs
guile-3.0 -c '(use-modules (ice-9 modules)) (display "OK\n")'
If that OK prints, your earlier extractor script should work again.

About Guix not in PATH and using the official installer

Yes, using the official install.sh is fine; in CI you still want to
start guix-daemon manually and add the Guix profile bins to PATH
across steps.
And yes, I’m prepending the checkout dir when generating docs so
modules resolve: GUILE_LOAD_PATH points at the repo root you’re
documenting.
Here’s a cleaned-up, single workflow that:

Uses the official install.sh
Starts the daemon explicitly
Adds the right PATH entries
Sets GUILE_LOAD_PATH so Documentá can import (guix …)/(gnu …)
Builds a single PDF
.github/workflows/documenta-guix.yml

YAML

name: Guix + Guile Documentá → Guix API PDF

on:
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-22.04
    env:
      LANG: C.UTF-8
      LC_ALL: C.UTF-8
      MODULE_SOURCES: "guix" # change to: "guix gnu" for everything (large)

    steps:
      - uses: actions/checkout@v4

      - name: Install host deps (Texinfo/PDF)
        run: |
          sudo apt-get update
          sudo apt-get install -y curl xz-utils git gnupg ca-certificates \
            texinfo \
            texlive-latex-base texlive-latex-recommended \
            texlive-fonts-recommended texlive-latex-extra

      - name: Install Guix via official script
        run: |
          set -eux
          curl -L https://guix.gnu.org/install.sh -o install.sh
          chmod +x install.sh
          # installer may try systemd bits; don't fail the job if
those parts error
          sudo -E ./install.sh || true

          # Ensure build users exist (idempotent)
          sudo groupadd --system guixbuild || true
          for i in $(seq -w 1 10); do
            sudo useradd -g guixbuild -G guixbuild -d /var/empty \
              -s "$(command -v nologin || echo /usr/sbin/nologin)" \
              -c "Guix build user $i" guixbuilder$i || true
          done

          # Start the daemon explicitly
          sudo -E
/var/guix/profiles/per-user/root/current-guix/bin/guix-daemon \
            --build-users-group=guixbuild \
            --disable-chroot \
            --substitute-urls='https://ci.guix.gnu.org
https://bordeaux.guix.gnu.org' &
          sleep 5

          # Make root's current-guix available to next steps
          echo "/var/guix/profiles/per-user/root/current-guix/bin" >>
"$GITHUB_PATH"
          guix --version

      - name: guix pull (user) and add to PATH
        run: |
          set -eux
          guix pull
          echo "$HOME/.config/guix/current/bin" >> "$GITHUB_PATH"
          guix describe

      - name: Install Guile Documentá
        run: |
          set -eux
          guix install guile-documenta
          echo "$HOME/.guix-profile/bin" >> "$GITHUB_PATH"
          which documenta
          documenta --version || true

      - name: Clone Guix sources (to document)
        run: |
          git clone --depth=1 https://git.savannah.gnu.org/git/guix.git

      - name: Generate Texinfo API with Documentá
        working-directory: guix
        env:
          # Prepend the checkout dir so (guix …)/(gnu …) resolve
          GUILE_LOAD_PATH: ${{ github.workspace }}/guix
        run: |
          mkdir -p doc
          documenta api $MODULE_SOURCES --destination doc/api
          cat > doc/main.texi <<'EOF'
          \input texinfo
          @setfilename guix-api
          @settitle Guix API (generated by Guile Documentá)
          @documentlanguage en
          @documentencoding UTF-8
          @node Top
          @top Guix API
          @menu
          * API::
          @end menu
          @node API
          @chapter API
          @include api/index.texi
          @bye
          EOF

      - name: Build PDF
        working-directory: guix/doc
        run: |
          makeinfo --no-split --pdf -o guix-api-documenta.pdf main.texi
          ls -lh guix-api-documenta.pdf

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: guix-api-documenta
          path: guix/doc/guix-api-documenta.pdf
Notes

PATH: We append three locations to GITHUB_PATH so later steps see guix
and documenta:
/var/guix/profiles/per-user/root/current-guix/bin (initial guix)
$HOME/.config/guix/current/bin (after guix pull)
$HOME/.guix-profile/bin (after guix install guile-documenta)
GUILE_LOAD_PATH: set to the Guix checkout so Documentá can load the
modules it’s documenting.
If guix install guile-documenta errors with “unknown package”, add the
author’s channel in $HOME/.config/guix/channels.scm and rerun. I can
drop that in if you paste the channel snippet/URL.
Optional: caching to speed up re-runs

You can pair the above with Actions cache for:
the Guix binary tarball (if you switch back to manual tarball install),
and a tar.zst of the store closure keyed by guix describe -f channels.
I can paste the cache-extended version once your first clean run
succeeds with install.sh.
If you still want the fast “introspection” route

Make sure you install both guile-3.0 and guile-3.0-libs, then run the
extractor. If it still fails, add a debug step:
name: Debug Guile stdlib
run: |
ls -l /usr/share/guile/3.0/ice-9 || true
test -f /usr/share/guile/3.0/ice-9/modules.scm && echo "modules.scm present"
guile-3.0 -c '(use-modules (ice-9 modules)) (display "OK\n")'
Ping me when the new run finishes (green or red), and I’ll adjust
quickly based on the logs.

It's still redownloading guix for the cache to test the new code.
Meanwhile, here's the path details for the much earlier failure:

text

0s
Run which guile || true
  which guile || true
  which guile-3.0 || true
  guile --version || true
  guile-3.0 --version
  guile-3.0 -c '(display (effective-version))(newline)'
  guile-3.0 -c '(for-each (lambda (p) (display p)(newline)) %load-path)'
  shell: /usr/bin/bash -e {0}
  env:
    LANG: C.UTF-8
    LC_ALL: C.UTF-8
/usr/bin/guile
/usr/bin/guile-3.0
guile (GNU Guile) 3.0.7
Packaged by Debian (3.0.7-deb+3.0.7-1)
Copyright (C) 2021 Free Software Foundation, Inc.

License LGPLv3+: GNU LGPL 3 or later <http://gnu.org/licenses/lgpl.html>.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
guile (GNU Guile) 3.0.7
Packaged by Debian (3.0.7-deb+3.0.7-1)
Copyright (C) 2021 Free Software Foundation, Inc.

License LGPLv3+: GNU LGPL 3 or later <http://gnu.org/licenses/lgpl.html>.
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
3.0
/usr/share/guile/3.0
/usr/share/guile/site/3.0
/usr/share/guile/site
/usr/share/guile
0s
Run guile-3.0 -c '(display %load-path)(newline)'
  guile-3.0 -c '(display %load-path)(newline)'
  guile-3.0 scripts/extract-docs.scm
  test -f build/guix-modules.md && head -n 20 build/guix-modules.md || true
  shell: /usr/bin/bash -e {0}
  env:
    LANG: C.UTF-8
    LC_ALL: C.UTF-8
    GUILE_LOAD_PATH: /home/runner/work/guix-docs-pdf-gpt/guix-docs-pdf-gpt/guix
(/home/runner/work/guix-docs-pdf-gpt/guix-docs-pdf-gpt/guix
/usr/share/guile/3.0 /usr/share/guile/site/3.0 /usr/share/guile/site
/usr/share/guile)
;;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=0
;;; or pass the --no-auto-compile argument to disable.
;;; compiling /home/runner/work/guix-docs-pdf-gpt/guix-docs-pdf-gpt/scripts/extract-docs.scm
;;; WARNING: compilation of
/home/runner/work/guix-docs-pdf-gpt/guix-docs-pdf-gpt/scripts/extract-docs.scm
failed:
;;; no code for module (ice-9 modules)
Backtrace:
           8 (primitive-load "/home/runner/work/guix-docs-pdf-gpt/gu…")
In ice-9/eval.scm:
   721:20 7 (primitive-eval (use-modules (ice-9 modules) (ice-9 …) …))
In ice-9/psyntax.scm:
  1230:36 6 (expand-top-sequence ((use-modules (ice-9 modules) # …)) …)
  1222:19 5 (parse _ (("placeholder" placeholder)) ((top) #(# # …)) …)
   259:10 4 (parse _ (("placeholder" placeholder)) (()) _ c&e (eval) …)
In ice-9/boot-9.scm:
  3927:20 3 (process-use-modules _)
   222:17 2 (map1 (((ice-9 modules)) ((ice-9 documentation)) ((…)) …))
  3928:31 1 (_ ((ice-9 modules)))
   3329:6 0 (resolve-interface (ice-9 modules) #:select _ #:hide _ # …)

ice-9/boot-9.scm:3329:6: In procedure resolve-interface:
no code for module (ice-9 modules)
Error: Process completed with exit code 1.
gpt-5-high

You’re right on both points:

guix not in PATH: after the binary extract, you must add
/var/guix/profiles/per-user/root/current-guix/bin to PATH (or call it
by its absolute path). Then, after guix pull and guix install, also
add the user profiles’ bin dirs.
Prepending the checkout dir: yes, set GUILE_LOAD_PATH to the repo root
when running documenta so it can resolve (guix …) and/or (gnu …)
modules.
Below is a clean, working workflow that fixes PATH and sets
GUILE_LOAD_PATH. Then I show an alternative that uses the official
install.sh and still manually starts the daemon (because systemd isn’t
guaranteed on GitHub runners).

Option A — Manual binary install (recommended for CI)
Minimal, reliable, and fast. Adds the right PATH entries and starts
the daemon explicitly.

.github/workflows/documenta-guix.yml

YAML

name: Guix + Guile Documentá → Guix API PDF

on:
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-22.04
    env:
      LANG: C.UTF-8
      LC_ALL: C.UTF-8
      # Document just the Guix module tree by default; change to:
"guix gnu" for everything (big).
      MODULE_SOURCES: "guix"

    steps:
      - uses: actions/checkout@v4

      - name: Install host deps (Texinfo/PDF)
        run: |
          sudo apt-get update
          sudo apt-get install -y curl xz-utils bzip2 git gnupg
ca-certificates \
            texinfo \
            texlive-latex-base texlive-latex-recommended \
            texlive-fonts-recommended texlive-latex-extra

      - name: Download Guix binary tarball
        run: |
          curl -L -o guix-binary.tar.xz
https://ftp.gnu.org/gnu/guix/guix-binary-1.4.0.x86_64-linux.tar.xz

      - name: Install Guix and start daemon
        run: |
          set -eux
          sudo tar --extract --file=guix-binary.tar.xz --directory=/
--no-same-owner --warning=no-unknown-keyword

          # Create build users (idempotent)
          sudo groupadd --system guixbuild || true
          for i in $(seq -w 1 10); do
            sudo useradd -g guixbuild -G guixbuild -d /var/empty \
              -s "$(command -v nologin || echo /usr/sbin/nologin)" \
              -c "Guix build user $i" guixbuilder$i || true
          done

          # Start daemon (we do it explicitly instead of via systemd)
          sudo -E
/var/guix/profiles/per-user/root/current-guix/bin/guix-daemon \
            --build-users-group=guixbuild \
            --disable-chroot \
            --substitute-urls='https://ci.guix.gnu.org
https://bordeaux.guix.gnu.org' &
          sleep 5

          # Make the initial root profile 'guix' visible to later steps
          echo "/var/guix/profiles/per-user/root/current-guix/bin" >>
"$GITHUB_PATH"
          guix --version

      - name: guix pull (user profile) and expose to PATH
        run: |
          set -eux
          guix pull
          # Add the per-user "current" profile to PATH for subsequent steps
          echo "$HOME/.config/guix/current/bin" >> "$GITHUB_PATH"
          guix describe

      - name: Install Guile Documentá
        run: |
          set -eux
          guix install guile-documenta
          # Add the user's default profile to PATH (where documenta lives)
          echo "$HOME/.guix-profile/bin" >> "$GITHUB_PATH"
          which documenta
          documenta --version || true

      - name: Clone Guix sources (to document)
        run: |
          git clone --depth=1 https://git.savannah.gnu.org/git/guix.git

      - name: Generate Texinfo API with Documentá
        working-directory: guix
        env:
          # Prepend the checkout dir so modules like (guix …) resolve
from ./guix
          GUILE_LOAD_PATH: ${{ github.workspace }}/guix
        run: |
          mkdir -p doc
          # e.g. MODULE_SOURCES: "guix" or "guix gnu"
          documenta api $MODULE_SOURCES --destination doc/api
          # Wrap in a tiny manual that includes the generated API
          cat > doc/main.texi <<'EOF'
          \input texinfo
          @setfilename guix-api
          @settitle Guix API (generated by Guile Documentá)
          @documentlanguage en
          @documentencoding UTF-8

          @node Top
          @top Guix API

          @menu
          * API::
          @end menu

          @node API
          @chapter API
          @include api/index.texi

          @bye
          EOF

      - name: Build PDF
        working-directory: guix/doc
        run: |
          makeinfo --no-split --pdf -o guix-api-documenta.pdf main.texi
          ls -lh guix-api-documenta.pdf

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: guix-api-documenta
          path: guix/doc/guix-api-documenta.pdf
Why this fixes your issues

guix not found: we explicitly add
/var/guix/profiles/per-user/root/current-guix/bin, then later add
$HOME/.config/guix/current/bin and $HOME/.guix-profile/bin to PATH
using $GITHUB_PATH (persists across steps).
“Prepending the checkout dir”: we set GUILE_LOAD_PATH to the repo root
when running documenta, so (guix …) and (gnu …) resolve from the
checked-out source tree even when modules import each other.
Option B — Use the official installer script
It’s fine to use, but on CI it may try to manage services with
systemd. We still start the daemon manually afterward to be safe.
Here’s how:

YAML

- name: Install Guix via official script, then start daemon manually
  run: |
    set -eux
    curl -L https://guix.gnu.org/install.sh -o install.sh
    chmod +x install.sh
    # installer may attempt to configure a system service; allow it to
fail without breaking CI
    sudo -E ./install.sh || true

    # Ensure the daemon is running (explicitly start it if not)
    sudo -E /var/guix/profiles/per-user/root/current-guix/bin/guix-daemon \
      --build-users-group=guixbuild \
      --disable-chroot \
      --substitute-urls='https://ci.guix.gnu.org
https://bordeaux.guix.gnu.org' &
    sleep 5

    echo "/var/guix/profiles/per-user/root/current-guix/bin" >> "$GITHUB_PATH"
    guix --version
Pros/cons of install.sh in CI

Pro: “Official.” Handles signature verification and user setup for you.
Con: Adds time (GPG verification), and service-manager steps may fail
or be no-ops on GitHub runners. You still need to add PATH and start
guix-daemon manually.
Extra tips

If you ever switch to documenting both guix and gnu, set
MODULE_SOURCES: "guix gnu". That can be very large; consider keeping
“guix” only at first.
If Documentá fails on a specific module that drags in FFI deps, we can
restrict the sources list or run Documentá under a guix shell with
extra inputs (e.g., guile-git). Tell me what it prints and I’ll tune
the inputs.
If you want, paste your current YAML and I’ll apply the exact edits
(PATH lines + GUILE_LOAD_PATH) so you don’t have to hunt for them on
your phone.

It isn't finding the guix binary in the path after your install step.
Would it be cleaner and work well to use the official script at
https://guix.gnu.org/install.sh ? Also, are you prepending the
checkout dir when generating documentation from the modules subdir?

gpt-5-high

Great q’s—quick clarity:

Yes, I already sent multiple workflows. This one is the “Guix installs
Documentá” path, which is the best fit because Documentá is a
Guix-native project (no Autotools). The earlier “build from Codeberg”
attempt isn’t ideal since it doesn’t ship a configure/make flow. The
Guile-introspection workflow is a faster fallback but less polished.
Best option for you: Guix + Documentá (recommended), optionally with
caching to speed up re-runs.
Caching: Yes. We can cache both the Guix binary tarball and a
compressed tar of the Guix store closure for Documentá so subsequent
runs avoid re-downloading most of Guix packages.
Here’s a single workflow that does all that, with caching.

.github/workflows/documenta-guix-cached.yml

YAML

name: Guix + Guile Documentá → Guix API PDF (cached)

on:
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-22.04
    env:
      LANG: C.UTF-8
      LC_ALL: C.UTF-8
      # Document just the Guix module tree by default; "guix gnu" is larger.
      MODULE_SOURCES: "guix"

    steps:
      - uses: actions/checkout@v4

      - name: Install host deps (Texinfo/PDF + zstd)
        run: |
          sudo apt-get update
          sudo apt-get install -y curl xz-utils zstd git \
            texinfo \
            texlive-latex-base texlive-latex-recommended \
            texlive-fonts-recommended texlive-latex-extra

      # Cache the Guix binary tarball to avoid re-downloading it.
      - name: Cache Guix binary tarball
        id: cache-guix-bin
        uses: actions/cache@v4
        with:
          path: .cache/guix/guix-binary-1.4.0.x86_64-linux.tar.xz
          key: guix-binary-1.4.0

      - name: Download Guix binary (if not cached)
        if: steps.cache-guix-bin.outputs.cache-hit != 'true'
        run: |
          mkdir -p .cache/guix
          curl -L -o .cache/guix/guix-binary-1.4.0.x86_64-linux.tar.xz \
            https://ftp.gnu.org/gnu/guix/guix-binary-1.4.0.x86_64-linux.tar.xz

      - name: Install Guix and start daemon
        run: |
          set -eux
          sudo tar --extract \
            --file=.cache/guix/guix-binary-1.4.0.x86_64-linux.tar.xz \
            --directory=/ --no-same-owner --warning=no-unknown-keyword
          sudo groupadd --system guixbuild || true
          for i in $(seq -w 1 10); do
            sudo useradd -g guixbuild -G guixbuild -d /var/empty \
              -s "$(command -v nologin || echo /usr/sbin/nologin)" \
              -c "Guix build user $i" guixbuilder$i || true
          done
          sudo -E
/var/guix/profiles/per-user/root/current-guix/bin/guix-daemon \
            --build-users-group=guixbuild \
            --disable-chroot \
            --substitute-urls='https://ci.guix.gnu.org
https://bordeaux.guix.gnu.org' &
          sleep 5
          guix --version

      - name: Configure Guix channels
        run: |
          mkdir -p "$HOME/.config/guix"
          cat > "$HOME/.config/guix/channels.scm" <<'EOF'
          (list
            (channel
              (name 'guix)
              (url "https://git.savannah.gnu.org/git/guix.git"))
            ;; If guile-documenta is not in your Guix, add the
author’s channel here:
            ;; (channel
            ;; (name 'documenta)
            ;; (url "https://codeberg.org/USER/CHANNEL.git"))
          )
          EOF
          cat "$HOME/.config/guix/channels.scm"

      - name: guix pull (update to latest)
        run: |
          set -eux
          guix pull
          . "$HOME/.config/guix/current/etc/profile"
          guix describe

      # Compute a cache key tied to the exact channel revision we just pulled.
      - name: Compute cache key from channels
        id: guix-key
        run: |
          set -eux
          . "$HOME/.config/guix/current/etc/profile"
          guix describe -f channels > channels.scm
          sha=$(sha256sum channels.scm | cut -d' ' -f1)
          echo "key=$sha" >> "$GITHUB_OUTPUT"
          mkdir -p cache

      # Try to restore a tar.zst of the Guix store closure for
Documentá+current-guix.
      - name: Restore Guix store cache
        id: store-cache
        uses: actions/cache@v4
        with:
          path: cache/guix-store-${{ steps.guix-key.outputs.key }}.tar.zst
          key: guix-store-${{ steps.guix-key.outputs.key }}

      - name: Extract cached store (if present)
        if: steps.store-cache.outputs.cache-hit == 'true'
        run: |
          sudo tar -I zstd -xf "cache/guix-store-${{
steps.guix-key.outputs.key }}.tar.zst" -C /

      - name: Install Guile Documentá via Guix
        run: |
          set -eux
          . "$HOME/.config/guix/current/etc/profile"
          guix install guile-documenta
          . "$HOME/.guix-profile/etc/profile"
          command -v documenta
          documenta --version || true

      # If we missed the cache, pack the closure for next runs.
      - name: Save store tarball for cache (closure)
        if: steps.store-cache.outputs.cache-hit != 'true'
        run: |
          set -eux
          . "$HOME/.config/guix/current/etc/profile"
          . "$HOME/.guix-profile/etc/profile"
          # Tar the transitive closures (requisites) of both the
current-guix and your profile.
          paths=$(guix gc --requisites "$HOME/.config/guix/current"
"$HOME/.guix-profile")
          sudo tar -I "zstd -T0 -19" -cf "cache/guix-store-${{
steps.guix-key.outputs.key }}.tar.zst" $paths
          ls -lh "cache/guix-store-${{ steps.guix-key.outputs.key
}}.tar.zst" || true

      - name: Clone Guix sources (to document)
        run: |
          git clone --depth=1 https://git.savannah.gnu.org/git/guix.git

      - name: Generate Texinfo API with Documentá
        working-directory: guix
        run: |
          mkdir -p doc
          # If documenting both 'guix' and 'gnu' (huge), set env
MODULE_SOURCES: "guix gnu"
          documenta api $MODULE_SOURCES --destination doc/api
          # Minimal wrapper manual including the generated API
          cat > doc/main.texi <<'EOF'
          \input texinfo
          @setfilename guix-api
          @settitle Guix API (generated by Guile Documentá)
          @documentlanguage en
          @documentencoding UTF-8

          @node Top
          @top Guix API

          @menu
          * API::
          @end menu

          @node API
          @chapter API
          @include api/index.texi

          @bye
          EOF

      - name: Build PDF from Texinfo
        working-directory: guix/doc
        run: |
          makeinfo --no-split --pdf -o guix-api-documenta.pdf main.texi
          ls -lh guix-api-documenta.pdf

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: guix-api-documenta
          path: guix/doc/guix-api-documenta.pdf
Which is “better” overall?

Guix + Documentá (this workflow): best output quality and structure;
maintained tool; integrates with Texinfo indices; you can include both
(guix …) and (gnu …) trees. First run is slow; caching helps a lot.
Guile-introspection scraper: fastest to set up, no Guix daemon, but
output is raw docstrings and less organized. Good fallback if you want
quick results.
Official manual build: solid, but you already noted it lacks the API
detail you need.
About caching

The workflow above:
Caches the Guix binary tarball (small win).
Caches a compressed tar of the Guix store closure for Documentá and
your current-guix revision, keyed by the channel commit. If the
channels haven’t changed, subsequent runs should skip most downloads
and finish much faster.
Caches are immutable per key; new channel commits => new cache key.
You can pin channels (guix time-machine) to keep a stable key if you
prefer reproducible/fast runs.
If you want me to pin Documentá to a specific channel commit (for even
better cache hits), tell me the channel URL and I’ll drop in a pinned
channels.scm or time-machine variant.

Didn't you already send me workflow source for this, or is this
different? Which is better? Can it cache the guix download?

gpt-5-high

You’re right: autoconf failing is expected here. Guile Documentá
doesn’t use Autotools; it’s a pure Guile project with a Guix manifest.
So the cleanest path on CI is to install/run it via Guix, not
“configure/make”.

Below is a drop-in GitHub Action that:

Bootstraps Guix
Installs guile-documenta from Guix (or from the author’s personal
channel, if needed)
Runs documenta to extract API Texinfo from the Guix source tree
Builds a single PDF you can download
You can copy-paste this on your phone.

.github/workflows/documenta-guix.yml

YAML

name: Guix + Guile Documentá → Guix API PDF

on:
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-22.04
    env:
      LANG: C.UTF-8
      LC_ALL: C.UTF-8
      # Adjust which module trees to document:
      MODULE_SOURCES: "guix" # change to: "guix gnu" (very large)

    steps:
      - uses: actions/checkout@v4

      - name: Install host deps (Texinfo/PDF toolchain)
        run: |
          sudo apt-get update
          sudo apt-get install -y curl xz-utils bzip2 git \
            texinfo \
            texlive-latex-base texlive-latex-recommended \
            texlive-fonts-recommended texlive-latex-extra

      - name: Install Guix (binary) and start daemon
        run: |
          set -eux
          # A known-good Guix binary tarball; newer will also work
          curl -L -o guix-binary.tar.xz
https://ftp.gnu.org/gnu/guix/guix-binary-1.4.0.x86_64-linux.tar.xz
          sudo tar --extract --file=guix-binary.tar.xz --directory=/
--no-same-owner --warning=no-unknown-keyword
          # Build users
          sudo groupadd --system guixbuild || true
          for i in $(seq -w 1 10); do
            sudo useradd -g guixbuild -G guixbuild -d /var/empty -s
"$(command -v nologin || echo /usr/sbin/nologin)" -c "Guix build user
$i" guixbuilder$i || true
          done
          # Start the daemon with standard substitute servers for speed
          sudo -E
/var/guix/profiles/per-user/root/current-guix/bin/guix-daemon \
            --build-users-group=guixbuild \
            --disable-chroot \
            --substitute-urls='https://ci.guix.gnu.org
https://bordeaux.guix.gnu.org' &
          sleep 5
          guix --version

      - name: Configure Guix channels
        run: |
          mkdir -p "$HOME/.config/guix"
          # If guile-documenta is available in official Guix for your
runner, this is enough.
          # If not, add the author's personal channel below (replace
URL with the real one).
          # Check the Guile Documentá README for the channel URL/snippet.
          cat > "$HOME/.config/guix/channels.scm" <<'EOF'
          (list
            (channel
              (name 'guix)
              (url "https://git.savannah.gnu.org/git/guix.git"))
            ;; Uncomment and set this channel if guile-documenta is
NOT in the official channel.
            ;; (channel
            ;; (name 'documenta)
            ;; (url
"https://codeberg.org/REPLACE-ME/documenta-guix-channel.git"))
          )
          EOF
          cat "$HOME/.config/guix/channels.scm"

      - name: guix pull and install guile-documenta
        run: |
          set -eux
          # Pull channels and install Documentá
          guix pull
          . "$HOME/.config/guix/current/etc/profile"
          guix describe
          guix install guile-documenta
          . "$HOME/.guix-profile/etc/profile"
          command -v documenta
          documenta --version || true

      - name: Clone Guix sources (to document)
        run: |
          git clone --depth=1 https://git.savannah.gnu.org/git/guix.git
          ls -la guix | head -n 50

      - name: Generate Texinfo API with Documentá
        working-directory: guix
        run: |
          mkdir -p doc
          # For older Documentá versions you may need quotes if
multiple sources:
          # documenta api "guix gnu" --destination doc/api
          documenta api $MODULE_SOURCES --destination doc/api
          # Minimal wrapper Texinfo that includes the generated API
          cat > doc/main.texi <<'EOF'
          \input texinfo
          @setfilename guix-api
          @settitle Guix API (generated by Guile Documentá)
          @documentlanguage en
          @documentencoding UTF-8

          @node Top
          @top Guix API

          The following API reference was generated from Guix source files
          using Guile Documentá.

          @menu
          * API::
          @end menu

          @node API
          @chapter API
          @include api/index.texi

          @bye
          EOF

      - name: Build PDF from Texinfo
        working-directory: guix/doc
        run: |
          makeinfo --no-split --pdf -o guix-api-documenta.pdf main.texi
          ls -lh guix-api-documenta.pdf

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: guix-api-documenta
          path: guix/doc/guix-api-documenta.pdf
What to expect and tweak

First run can be slow while Guix downloads substitutes. It’s normal.
Subsequent runs will be faster on a warm runner, but GitHub runners
are ephemeral, so consider running at off-peak times.
If guix install guile-documenta fails with “unknown package”, add the
author’s channel to channels.scm. The manual mentions a “personal Guix
Channel X.” Paste its exact Codeberg URL/name and I’ll pin it in the
workflow for you.
Scope: MODULE_SOURCES is "guix" by default (sane size). If you change
it to "guix gnu", the PDF will be much larger and take longer.
Why the earlier “autoconf” attempt broke

Documentá doesn’t ship a configure/make build; it’s Guile + a Guix
manifest. Installing via Guix or running the script in a Guix shell is
the intended workflow.
If you need a no-Guix fallback

We can still use the Guile-introspection scraper I gave before (fixed
to call guile-3.0 explicitly) and generate a quick-and-dirty PDF. It
won’t be as polished as Documentá’s Texinfo, but it works without
Guix. Say the word and I’ll post a minimal YAML+script bundle.
Want me to wire the exact Documentá channel now?

Share the channel snippet or Codeberg URL (from the project README),
and which module trees you want (guix only, or guix+gnu). I’ll drop it
into the channels.scm block and push a tuned workflow.

It's checking out from codeberg now but autoconf fails; documenta is
in scheme and has only a guix manifest file.
The other workflows are still processing, guix is downloading slowly.
The official manual build failed but I didn't look into it because I
have a copy of the manual and the api documentation is lacking for me.

gpt-5-high

Short answer: yes, using Guix to install Guile Documentá is
reasonable. On GitHub Actions you just need to bootstrap Guix (start a
guix-daemon), then guix install guile-documenta, run documenta, and
render the generated Texinfo to PDF.

Below are two copy‑paste workflows you can add from your phone.

Option 1 — Use Guix to install Guile Documentá, then build PDF
This sets up a working Guix on the GitHub runner, installs
guile-documenta with guix, generates Texinfo from the Guix sources,
and compiles it into a single PDF.

In your repo, create .github/workflows/documenta-guix.yml with:
YAML

name: Guix + Documentá (build Guix API PDF)

on:
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-22.04
    env:
      LANG: C.UTF-8
      LC_ALL: C.UTF-8

    steps:
      - uses: actions/checkout@v4

      - name: Install host deps (for PDF)
        run: |
          sudo apt-get update
          sudo apt-get install -y curl xz-utils bzip2 git \
            texinfo \
            texlive-latex-base texlive-latex-recommended \
            texlive-fonts-recommended texlive-latex-extra

      - name: Install Guix (binary) and start daemon
        run: |
          set -eux
          curl -L -o guix-binary.tar.xz
https://ftp.gnu.org/gnu/guix/guix-binary-1.4.0.x86_64-linux.tar.xz
          sudo tar --extract --file=guix-binary.tar.xz --directory=/
--no-same-owner --warning=no-unknown-keyword
          # Build users
          sudo groupadd --system guixbuild || true
          for i in $(seq -w 1 10); do
            sudo useradd -g guixbuild -G guixbuild -d /var/empty -s
"$(command -v nologin || echo /usr/sbin/nologin)" -c "Guix build user
$i" guixbuilder$i || true
          done
          # Start daemon (non-chroot is fine for Actions)
          sudo -E
/var/guix/profiles/per-user/root/current-guix/bin/guix-daemon
--build-users-group=guixbuild --disable-chroot &
          sleep 5
          /var/guix/profiles/per-user/root/current-guix/bin/guix --version

      - name: Configure Guix channels (add Documentá channel if needed)
        run: |
          mkdir -p "$HOME/.config/guix"
          # If Documentá is in a personal channel, add it here.
          # Replace the URL below with the correct one for Documentá's channel.
          cat > "$HOME/.config/guix/channels.scm" <<'EOF'
          (list
            (channel
              (name 'guix)
              (url "https://git.savannah.gnu.org/git/guix.git"))
            ;; If Documentá isn't in the official Guix channel,
uncomment and set:
            ;; (channel
            ;; (name 'documenta)
            ;; (url "https://codeberg.org/USER/CHANNEL.git"))
          )
          EOF
          cat "$HOME/.config/guix/channels.scm"

      - name: guix pull and install guile-documenta
        run: |
          set -eux
          guix pull
          . "$HOME/.config/guix/current/etc/profile"
          guix install guile-documenta
          . "$HOME/.guix-profile/etc/profile"
          which documenta
          documenta --version || true

      - name: Clone Guix sources
        run: |
          git clone --depth=1 https://git.savannah.gnu.org/git/guix.git

      - name: Generate Texinfo with Documentá
        working-directory: guix
        run: |
          mkdir -p doc
          # Document only the 'guix' module tree to keep PDF size sane.
          # You can add 'gnu' too (huge) by passing: "guix gnu"
          documenta api guix --destination doc/api
          # Minimal wrapper to include the generated API into one PDF
          cat > doc/main.texi <<'EOF'
          \input texinfo
          @setfilename guix-api
          @settitle Guix API (generated by Guile Documentá)
          @documentlanguage en
          @documentencoding UTF-8
          @node Top
          @top Guix API
          API extracted from the Guix source tree using Guile Documentá.

          @menu
          * API::
          @end menu

          @node API
          @chapter API
          @include api/index.texi

          @bye
          EOF

      - name: Build PDF from Texinfo
        working-directory: guix/doc
        run: |
          makeinfo --no-split --pdf -o guix-api-documenta.pdf main.texi
          ls -lh guix-api-documenta.pdf

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: guix-api-documenta
          path: guix/doc/guix-api-documenta.pdf
What to edit:

If guile-documenta is not in the official Guix channel on your runner,
you must add its channel URL in the channels.scm step. Please paste
the channel URL for Documentá (from its Codeberg README) and I’ll drop
it in for you.
Pros/cons:

Pro: Very “Guix-y,” reproducible once pinned. You can also pin with
guix time-machine for exact commits.
Con: First run takes longer (guix pull + install), typically 5–15 minutes.
Option 2 — Skip Guix; build Documentá from Codeberg and run it
If you’d rather avoid setting up Guix in Actions, you can compile
Documentá from its Codeberg repo and use the system Guile. Update the
repo URL if it differs.

Create .github/workflows/documenta-codeberg.yml:

YAML

name: Documentá from Codeberg (build Guix API PDF)

on:
  workflow_dispatch:

jobs:
  build:
    runs-on: ubuntu-22.04
    env:
      LANG: C.UTF-8
      LC_ALL: C.UTF-8
      PREFIX: ${{ github.workspace }}/.local

    steps:
      - uses: actions/checkout@v4

      - name: Install deps (Guile, build tools, Texinfo/LaTeX)
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            git autoconf automake libtool make pkg-config \
            guile-3.0 guile-3.0-dev \
            texinfo \
            texlive-latex-base texlive-latex-recommended \
            texlive-fonts-recommended texlive-latex-extra

      - name: Clone and build Guile Documentá (Codeberg)
        run: |
          set -eux
          git clone --depth=1
https://codeberg.org/luis-felipe/guile-documenta.git
          cd guile-documenta
          autoreconf -vfi || true
          ./configure --prefix="$PREFIX"
          make -j"$(nproc)"
          make install
          echo "$PREFIX/bin" >> "$GITHUB_PATH"
          documenta --version || true

      - name: Clone Guix sources
        run: |
          git clone --depth=1 https://git.savannah.gnu.org/git/guix.git

      - name: Generate Texinfo with Documentá
        working-directory: guix
        run: |
          mkdir -p doc
          documenta api guix --destination doc/api
          cat > doc/main.texi <<'EOF'
          \input texinfo
          @setfilename guix-api
          @settitle Guix API (generated by Guile Documentá)
          @documentlanguage en
          @documentencoding UTF-8
          @node Top
          @top Guix API
          @menu
          * API::
          @end menu
          @node API
          @chapter API
          @include api/index.texi
          @bye
          EOF

      - name: Build PDF
        working-directory: guix/doc
        run: |
          makeinfo --no-split --pdf -o guix-api-documenta.pdf main.texi

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: guix-api-documenta
          path: guix/doc/guix-api-documenta.pdf
Notes and tips

Which path should you use? If you want to be 100% “Guix-native,” pick
Option 1. If you just want a working PDF fast, Option 2 is simpler.
Big vs small: Documenting the entire gnu/ directory will produce a
massive manual; start with just guix/ as shown. You can later run
documenta api "guix gnu" if you want everything.
Pinning with time-machine: For reproducibility with Option 1, replace
guix pull with guix time-machine -C channels.scm -- install
guile-documenta and put exact commits in channels.scm.
Your earlier error no code for module (ice-9 modules) came from a
mismatched/old Guile. Both options above avoid that by either using
Guix’s Guile (Option 1) or explicitly installing guile-3.0 (Option 2).
If you can share the exact Codeberg repo URL for Documentá’s channel
(if it has one), I’ll update Option 1’s channels.scm block so guix
install guile-documenta works out of the box.

It tries to clone documenta from gitlab but it's on codeberg. It would
seem best to use guix to install it with guix install guile-documenta.
Is that reasonable?

gpt-5-high

Thanks for the link — yes, Guile Documentá is real and looks
maintained (it even has a 2025 changelog). We can use it. But first,
let’s fix the error you hit.

Why you got “no code for module (ice-9 modules)”

On ubuntu-latest, the guile binary on PATH can be a stub or an
older/minimal build without standard modules.
Installing guile-3.0 doesn’t necessarily make /usr/bin/guile point to it.
When your workflow ran guile scripts/extract-docs.scm, it likely
invoked the wrong guile. Hence it can’t even load (ice-9 modules).
Two solid fixes
A) Call guile-3.0 explicitly and remove package conflicts.
B) Also, your Scheme script needs (use-modules (ice-9 documentation))
and should not crash if “build/” exists.

Below are copy-pasteable updates.

Patch your current Option B workflow
Replace your .github/workflows/build-api-docs.yml with this:

YAML

name: Build API docs from Guix docstrings (PDF)

on:
  workflow_dispatch:
  push:
    branches: [ main, master ]

jobs:
  api-docs:
    runs-on: ubuntu-22.04 # more predictable Guile packaging

    env:
      LANG: C.UTF-8
      LC_ALL: C.UTF-8

    steps:
      - uses: actions/checkout@v4

      - name: Install deps (Guile 3.0, Pandoc, LaTeX)
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            git ca-certificates \
            guile-3.0 \
            pandoc \
            texlive-latex-base texlive-latex-recommended \
            texlive-fonts-recommended texlive-latex-extra
          # Show which guile we have
          which guile || true
          guile --version || true
          which guile-3.0
          guile-3.0 --version

      - name: Clone Guix sources (for module load path)
        run: |
          git clone --depth=1 https://git.savannah.gnu.org/git/guix.git
          ls -la guix | head -n 50

      - name: Extract docstrings to Markdown (force Guile 3.0)
        env:
          GUILE_LOAD_PATH: ${{ github.workspace }}/guix
        run: |
          guile-3.0 -c '(display %load-path)(newline)'
          guile-3.0 scripts/extract-docs.scm
          test -f build/guix-modules.md && head -n 20
build/guix-modules.md || true

      - name: Convert Markdown to PDF via pandoc
        run: |
          pandoc build/guix-modules.md \
            -V geometry:margin=1in \
            -V documentclass:article \
            -o build/guix-api-docs.pdf

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: guix-api-docs
          path: build/guix-api-docs.pdf
Update your extractor script
Replace scripts/extract-docs.scm with this:

scheme

#!/usr/bin/env -S guile-3.0 -e main -s
!#
;; Extract Guix module docs from docstrings into a Markdown file.
;; Produces: build/guix-modules.md
;; Requires GUILE_LOAD_PATH to include the Guix checkout (the repo top-level).

(use-modules (ice-9 modules)
             (ice-9 documentation)
             (ice-9 pretty-print)
             (ice-9 format)
             (srfi srfi-1))

(define major-modules
  '((guix)
    (guix utils)
    (guix records)
    (guix licenses)
    (guix base32)
    (guix download)
    (guix git)
    (guix gexp)
    (guix packages)
    (guix profiles)
    (guix store)
    (guix build-system)
    (guix build-system gnu)
    (guix build-system cmake)
    (guix build-system go)
    (guix build-system python)
    (guix build-system emacs)))

(define (safe thunk)
  (catch #t (lambda () (thunk))
             (lambda args #f)))

(define (var->doc var)
  (safe
   (lambda ()
     (let ((val (and (variable-bound? var) (variable-ref var))))
       (or (and val (procedure? val) (procedure-documentation val))
           (variable-documentation var)
           #f)))))

(define (module->entries m)
  (let ((entries '())
        (iface (module-public-interface m)))
    (module-map
     (lambda (sym var)
       (let ((doc (var->doc var)))
         (when (and doc (string? doc) (not (string-null? doc)))
           (set! entries (cons (list sym doc) entries)))))
     iface)
    (sort entries (lambda (a b)
                    (string-ci<? (symbol->string (car a))
                                 (symbol->string (car b)))))))

(define (module-name->string name)
  (string-join (map symbol->string name) " "))

(define (mkdir-p path)
  (false-if-exception (mkdir path #o755)))

(define (doc-module port name)
  (let ((m (safe (lambda () (resolve-interface name)))))
    (if (not m)
        (format port "\n# Module (~a)\n\nCould not load this module
(skipped).\n"
                (module-name->string name))
        (let* ((entries (module->entries m)))
          (format port "\n# Module (~a)\n\n" (module-name->string name))
          (if (null? entries)
              (format port "_No documented bindings found._\n\n")
              (for-each
               (lambda (pair)
                 (let ((sym (car pair)) (doc (cadr pair)))
                   (format port "## ~a\n\n" (symbol->string sym))
                   ;; Docstrings are often Texinfo; we keep them as-is.
                   (format port "~a\n\n" doc)))
               entries))))))

(define (main args)
  (let ((out-dir "build")
        (out-file "build/guix-modules.md"))
    (mkdir-p out-dir)
    (call-with-output-file out-file
      (lambda (port)
        (format port "# Guix API (docstrings dump)\n\n")
        (for-each (lambda (name) (doc-module port name))
                  major-modules)))
    (format #t "Wrote ~a\n" out-file)))
What changed

We call guile-3.0 explicitly in the workflow and the script shebang.
We removed apt guix (that package can confuse Guile on Ubuntu runners).
We add GUILE_LOAD_PATH=$GITHUB_WORKSPACE/guix so imports like (guix
gexp) resolve from the cloned Guix repo.
The script now imports (ice-9 documentation) and won’t fail if build/
already exists.
Optional: Use Guile Documentá instead (clean Texinfo → PDF)
If you’d like polished Texinfo output generated from the sources (and
then a single PDF), Documentá is a good fit. Here’s a workflow that
builds Documentá from source, runs it on the Guix checkout, and
compiles the result to a PDF:

YAML

name: Build Guix API docs with Guile Documentá (PDF)

on:
  workflow_dispatch:

jobs:
  documenta:
    runs-on: ubuntu-22.04

    env:
      LANG: C.UTF-8
      LC_ALL: C.UTF-8
      PREFIX: ${{ github.workspace }}/.local

    steps:
      - uses: actions/checkout@v4

      - name: Install toolchain
        run: |
          sudo apt-get update
          sudo apt-get install -y \
            git ca-certificates \
            guile-3.0 \
            autoconf automake libtool make pkg-config \
            texinfo \
            texlive-latex-base texlive-latex-recommended \
            texlive-fonts-recommended texlive-latex-extra

      - name: Clone and build Guile Documentá
        run: |
          git clone --depth=1 https://gitlab.com/luis-felipe/guile-documenta.git
          cd guile-documenta
          # If the release already ships 'configure', you can skip autoreconf
          autoreconf -vfi || true
          ./configure --prefix="$PREFIX"
          make -j$(nproc)
          make install
          echo "$PREFIX/bin" >> $GITHUB_PATH
          documenta --help || true

      - name: Clone Guix sources
        run: |
          git clone --depth=1 https://git.savannah.gnu.org/git/guix.git
          ls guix | head -n 20

      - name: Generate Texinfo API with Documentá
        working-directory: guix
        run: |
          mkdir -p doc
          # Generate API texi into doc/api from the 'guix' module directory
          documenta api guix --destination doc/api
          # Create a tiny main.texi that includes the generated API
          cat > doc/main.texi <<'EOF'
          \input texinfo
          @setfilename guix-api
          @settitle Guix API (generated by Guile Documentá)
          @documentlanguage en
          @documentencoding UTF-8

          @node Top
          @top Guix API

          The following API reference was generated from Guix source files
          using Guile Documentá.

          @menu
          * API::
          @end menu

          @node API
          @chapter API
          @include api/index.texi

          @bye
          EOF

      - name: Build PDF from Texinfo (makeinfo/texi2pdf)
        working-directory: guix/doc
        run: |
          makeinfo --no-split --pdf -o guix-api-documenta.pdf main.texi
          ls -lh guix-api-documenta.pdf

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: guix-api-documenta
          path: guix/doc/guix-api-documenta.pdf
Notes on the Documentá workflow

We build Documentá from its GitLab repo directly. If the build system
evolves, this may need small tweaks (configure flags, etc.). The
command documenta api guix points it at the guix/guix directory; you
can pass more sources, e.g. "guix gnu".
You get nicely structured Texinfo and indices; the PDF will look
closer to hand-written manuals than a raw dump.
If anything still breaks
Add this diagnostic step before running your script:

YAML

- name: Diagnose Guile paths
  run: |
    which guile || true
    which guile-3.0 || true
    guile --version || true
    guile-3.0 --version
    guile-3.0 -c '(display (effective-version))(newline)'
    guile-3.0 -c '(for-each (lambda (p) (display p)(newline)) %load-path)'
Want me to tune the module list, split PDFs per module, or wire
Documentá to include both (guix …) and (gnu …) trees?

I ran into this error:

Run

  guile scripts/extract-docs.scm
  test -f build/guix-modules.md && head -n 20 build/guix-modules.md || true
  shell: /usr/bin/bash -e {0}
;;; note: auto-compilation is enabled, set GUILE_AUTO_COMPILE=0
;;; or pass the --no-auto-compile argument to disable.
;;; compiling /home/runner/work/guix-docs-pdf-gpt/guix-docs-pdf-gpt/scripts/extract-docs.scm
;;; WARNING: compilation of
/home/runner/work/guix-docs-pdf-gpt/guix-docs-pdf-gpt/scripts/extract-docs.scm
failed:
;;; no code for module (ice-9 modules)
Backtrace:
           8 (primitive-load "/home/runner/work/guix-docs-pdf-gpt/gu…")
In ice-9/eval.scm:
   721:20 7 (primitive-eval (use-modules (ice-9 modules) (ice-9 …) …))
In ice-9/psyntax.scm:
  1229:36 6 (expand-top-sequence (#<syntax:extract-docs.scm:6:0 (…>) …)
  1221:19 5 (parse _ (("placeholder" placeholder)) ((top) #(# # …)) …)
   259:10 4 (parse _ (("placeholder" placeholder)) (()) _ c&e (eval) …)
In ice-9/boot-9.scm:
  3935:20 3 (process-use-modules _)
   222:17 2 (map1 (((ice-9 modules)) ((ice-9 rdelim)) ((ice-9 #)) …))
  3936:31 1 (_ ((ice-9 modules)))
   3330:6 0 (resolve-interface (ice-9 modules) #:select _ #:hide _ # …)

ice-9/boot-9.scm:3330:6: In procedure resolve-interface:
no code for module (ice-9 modules)
Error: Process completed with exit code 1.```
Guile Documentá is at https://luis-felipe.gitlab.io/guile-documenta/ .
Here's the manual main page:
```\input texinfo
@setfilename guile-documenta

@c HEADER
@settitle Guile Documentá
@documentlanguage en
@documentencoding UTF-8
@afourpaper
@c END HEADER

@c MASTER MENU
@node Top
@top Overview

This software is a command-line program and accompanying library
to generate API documentation for
@url{https://www.gnu.org/software/guile/, GNU Guile} Scheme projects.
You can find additional information in
@url{https://luis-felipe.gitlab.io/guile-documenta/, Guile Documentá's website}.

Note that a copy of this documentation should also be available locally
in your device, in @code{info} format, once you install the program. You
can browse it with any info reader. For example:

@example
$ info guile-documenta
@end example

Guile Documentá is a
@url{https://freedomdefined.org/Definition, Free Cultural Work}
(@pxref{Copying Information}).

(The word @emph{documentá} is an imperative form of the Spanish verb
@emph{documentar}, which means @emph{to document}.)

@menu
Chapters

* Usage::
  Generating documentation from source code.
* CLI::
  Command-line interface reference.
* API::
  Application programming interface reference.

Appendices

* Version History::
  Versions released so far and summary of the changes introduced in each
  of them.
* Copying Information::
  About the dedication of Guile Documentá to the public domain.

Indices

* Concept Index::
* Data Type Index::
* Procedure Index::
* Variable Index::

@c Here you can put a detailmenu command to add exactly that.

@end menu
@c END MASTER MENU

@c TABLE OF CONTENTS
@contents
@c END TABLE OF CONTENTS

@c CHAPTER: Usage
@node Usage
@chapter Usage

Guile Documentá comes with a program called @command{documenta}, which
you can use to generate API documentation for your Guile Scheme project.
The resulting documentation will be written in
@url{https://www.gnu.org/software/texinfo/, Texinfo} format.

For example, let's suppose we have a project called @sc{Bogus X} and
that we keep its source files in a folder as follows:

@example
bogus-x ← Project directory
├── bogusx ← Guile Scheme "package"
│   ├── module-a.scm ← Guile Scheme module
│   └── module-b.scm
├── doc ← Project documentation in Texinfo format
│   └── main.texi
├── tests
└── README.org
@end example

In the example, the project already has some documentation written by
hand in @file{doc/main.texi}, and we want to complement it with API
documentation. To do so, we generate it as follows:

@example
$ cd bogus-x
$ documenta api bogusx
@end example

The @ref{cli-api, api} subcommand will inspect all the modules in the
@file{bogusx} directory and build API reference documentation that
will then be saved in Texinfo format to the @file{doc/api} folder:

@example
bogus-x
├── bogusx
├── doc
│   ├── api ← Newly extracted API documentation
│   │   └── index.texi
│   └── main.texi
├── tests
└── README.org
@end example

For more complex projects, you can pass a quoted list of the module
files and directories that compose the whole API of the project. For
example:

@example
$ cd another-project
$ documenta api "mylib.scm mylib"
@end example

Finally, we can integrate the API documentation into the
@file{main.texi} documentation using Texinfo's @code{@@include}
command. For example:

@verbatim
@include api/index.texi
@end verbatim
@c END CHAPTER: Usage

@c CHAPTER: CLI
@node CLI
@chapter CLI

Guile Documentá comes with the @command{documenta} program, which
recognizes the following subcommands:

@quotation Note
Guile Documentá does not currently extract @abbr{CLI, Command Line
Interface} documentation from the source code, but it is intended to
do so in the future. The following documentation is (re)written by
hand (sadly).
@end quotation

@anchor{cli-api}
@section @code{api} command

The @code{api} command extracts @abbr{API, Application Programming
Interface} documentation from one or more Guile Scheme modules.

@subsection Examples

@example
# Extract API documentation from one Scheme file:
documenta api mylib.scm

# Extract API documentation from one Scheme directory (recursively):
documenta api mylib

# Extract API documentation from both a Scheme file and directory:
documenta api "mylib.scm mylib"
@end example

@quotation Note
Having to quote the list of sources in the last example is a limitation
that is expected to be removed in the future. So it could simply become:

@example
documenta api mylib.scm mylib etc
@end example
@end quotation

@example
# Save API documentation to a specific directory:
documenta api mylib --destination mydoc/api
@end example

@subsection Interface specification

@verbatim
documenta api sources [--destination]
@end verbatim

@defblock
@defline Argument sources
Absolute or relative paths to Guile Scheme modules that compose the
code whose API documentation will be extracted. These paths can lead
to both Scheme files or Scheme directories.

@defline {Keyword argument} --destination or -d
Optional path to a directory where the final
Texinfo files will be saved. If not provided, @var{DEFAULT_DOC_PATH}
is used (see the module @ref{documenta_commands}).
@end defblock
@c END CHAPTER: CLI

@c CHAPTER: API
@include api/index.texi
@c END CHAPTER: API

@c APPENDICES
@node Version History
@appendix Version History

@table @dfn
@item Version 0.4.0, July 05, 2025
@itemize
@item
@code{api} command: The @code{source} argument is now called
@code{sources} and accepts one or more paths to Guile Scheme
modules or Guile Scheme directories. For example:

@example
$ documenta api libx.scm
$ documenta api liby
$ documenta api "libz.scm libz"
@end example

@item
@code{api} command: The @code{destination} argument, which was a
positional argument, became a keyword argument called
@code{--destination}, and abbreviated as @code{-d}.
@end itemize

@item Version 0.3.0, June 22, 2025
@itemize
@item
Macros are now documented with name, arguments and documentation
strings instead of simply copied verbatim to the exported
documentation.
@item
Added support to document parameter objects. Module documentation
sections now include a "Parameters" subsection if they export
parameters. The parameters are also listed in the "Variable Index".
@end itemize

@item Version 0.2.1, Oct 16, 2023
@itemize
@item
Enable installing Guile Documentá from the package provided by my
personal Guix Channel X. Two unit tests that pass in Guile Documentá's
development environment (which uses Guix shell) were failing when
building the package with Guix. Both tests were marked as expected
fails to make the test suite pass regardless of the issues and be able
to install the package successfully. This is a temporary fix until the
origin of the issues is found.
@end itemize

@item Version 0.2.0, May 31, 2023
@itemize
@item
Rename @command{extract} command to @command{api} so that it is
easier to separate API documentation and CLI documentation extraction.
@item
Add project website.
@end itemize

@item Version 0.1.0, April 13, 2023
@itemize
@item
Initial release of the software providing a program to generate API
documentation of Guile Scheme libraries in Texinfo format.
@end itemize
@end table

@node Copying Information
@appendix Copying Information

Public domain 2023 @url{https://luis-felipe.gitlab.io/, Luis Felipe
López Acevedo}. All rights waived.

Guile Documentá has been released into the public domain by its
author. This applies universewide.
@c END APPENDICES

@c INDICES
@node Concept Index
@unnumbered Concept Index

@printindex cp

@node Data Type Index
@unnumbered Data Type Index

@printindex tp

@node Procedure Index
@unnumbered Procedure Index

@printindex fn

@node Variable Index
@unnumbered Variable Index

@printindex vr
@c END INDICES

@bye
gpt-5-high

Short answer: there isn’t a widely adopted, actively maintained
“Sphinx-for-Guile” doc generator. I’m not confident that Guile
Documentá is maintained or commonly used. If you can share the repo
you mean, I can evaluate it and wire it up—but for something stable
today, the most “maintained” path is to use Guile’s built-ins.

What is maintained and works reliably

Guile’s own introspection:
procedure-documentation, variable-documentation from (ice-9 documentation)
resolve-interface / module-map from (ice-9 modules)
Texinfo toolchain:
Docstrings in Guile/Guix are typically Texinfo fragments; you can dump
them and render with makeinfo/texi2pdf.
Geiser (Emacs) uses the same Guile APIs for “help,” but it’s not a
standalone generator.
Comparable options

Roll-your-own with the Guile runtime (maintained, stable): enumerate
exports, read docstrings, assemble a .texi or .md, and then render to
PDF. I can give you a ready-to-run script and a GitHub Action (I
already shared a Markdown+Pandoc version; I can also give a
Texinfo-based one for cleaner formatting).
Use the official Guix manual (Texinfo) and build the PDF. This is the
canonical, maintained documentation for Guix modules and is what most
users rely on.
If you were specifically thinking of a project named “Documentá,”
point me to its URL and I’ll integrate it into a GH Action for you.
Otherwise, want me to drop in a Texinfo-based scraper (Guile-only, no
Pandoc) so you get a single polished PDF built in Actions?

Are you familiar with Guile Documentá or any comparable tool for
scraping docstrings in a maintained manner?

gpt-5-high

Got you. Easiest path: let GitHub Actions do the heavy lifting in the
cloud and you just download the PDF on your phone. Below are two
ready-to-use setups:

Option A (recommended): Build the official Guix manual as a single
PDF. It already documents most major modules and APIs.
Option B (experimental): Auto-generate API docs from Guile/Guix
docstrings and compile to PDF.
I’ll give you copy-paste files and step-by-step instructions you can
do from a phone.

Option A — Build the official Guix manual PDF
This uses Texinfo sources from the Guix repo and produces a
guix-manual.pdf artifact.

Make a new GitHub repo (empty)
On your phone: GitHub → + → New repository → name it guix-docs-pdf
(anything works)
Add this workflow file
In your repo, Add file → Create new file
Path: .github/workflows/build-guix-manual.yml
Paste this:
YAML

name: Build Guix manual (PDF)

on:
  workflow_dispatch:
  push:
    branches: [ main, master ]

jobs:
  manual:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout (empty repo is fine)
        uses: actions/checkout@v4

      - name: Install toolchain
        run: |
          sudo apt-get update
          sudo apt-get install -y git texinfo \
            texlive-latex-base texlive-latex-recommended \
            texlive-fonts-recommended texlive-latex-extra \
            texlive-plain-generic

      - name: Fetch Guix sources (doc only)
        run: |
          git clone --depth=1 https://git.savannah.gnu.org/git/guix.git
          cd guix/doc
          # Minimal version.texi so we don't need ./configure
          cat > version.texi <<'EOF'
          @c Autogenerated by GitHub Actions
          @set EDITION snapshot
          @set VERSION snapshot
          @set UPDATED 2025-01-01
          @set UPDATED-MONTH Jan
          EOF

      - name: Build PDF with makeinfo
        working-directory: guix/doc
        run: |
          makeinfo --no-split --pdf -o guix-manual.pdf guix.texi

      - name: Upload PDF artifact
        uses: actions/upload-artifact@v4
        with:
          name: guix-manual-pdf
          path: guix/doc/guix-manual.pdf
Run it
Go to Actions → Build Guix manual (PDF) → Run workflow.
When it finishes, open the run → Artifacts → guix-manual-pdf → download the PDF.
Notes

This is the official manual. It includes the “Programming Interface”
chapters that document major modules like (guix packages), (guix
gexp), etc. For most use cases, this is what you want.
Option B — Generate API docs from Guix docstrings, then PDF
This tries to load Guix modules in Guile, pull their docstrings, write
Markdown, and then convert to PDF. It’s more “codey,” can be tweaked,
and might miss undocumented bindings.

Add the extractor script
Add file → Create new file
Path: scripts/extract-docs.scm
Paste:
scheme

#!/usr/bin/env guile
!#
;; Extract Guix module docs from docstrings into a Markdown file.
;; Produces: build/guix-modules.md

(use-modules (ice-9 modules)
             (ice-9 rdelim)
             (ice-9 pretty-print)
             (ice-9 format)
             (srfi srfi-1))

(define major-modules
  '((guix)
    (guix utils)
    (guix records)
    (guix licenses)
    (guix base32)
    (guix download)
    (guix git)
    (guix gexp)
    (guix packages)
    (guix profiles)
    (guix store)
    (guix build-system gnu)
    (guix build-system cmake)
    (guix build-system go)
    (guix build-system python)
    (guix build-system emacs)))

(define (safe thunk)
  (catch #t (lambda () (thunk))
             (lambda args #f)))

(define (var->doc var)
  (safe
   (lambda ()
     (let ((val (and (variable-bound? var) (variable-ref var))))
       (or (and val (procedure? val) (procedure-documentation val))
           (variable-documentation var)
           #f)))))

(define (module->entries m)
  (let ((entries '()))
    (module-map
     (lambda (sym var)
       (let ((doc (var->doc var)))
         (when (and doc (string? doc) (not (string-null? doc)))
           (set! entries (cons (list sym doc) entries)))))
     m)
    (sort entries (lambda (a b)
                    (string-ci<? (symbol->string (car a))
                                 (symbol->string (car b)))))))

(define (module-name->string name)
  (string-join (map symbol->string name) " "))

(define (doc-module port name)
  (let ((m (safe (lambda () (resolve-interface name)))))
    (if (not m)
        (format port "\n# Module (~a)\n\nCould not load this module
(skipped).\n"
                (module-name->string name))
        (let* ((entries (module->entries m)))
          (format port "\n# Module (~a)\n\n" (module-name->string name))
          (if (null? entries)
              (format port "_No documented bindings found._\n\n")
              (for-each
               (lambda (pair)
                 (let ((sym (car pair)) (doc (cadr pair)))
                   (format port "## ~a\n\n" (symbol->string sym))
                   ;; Docstrings in Guix often use Texinfo; we leave them as-is.
                   (format port "~a\n\n" doc)))
               entries))))))

(define (main args)
  (let ((out-dir "build")
        (out-file "build/guix-modules.md"))
    (mkdir out-dir 493) ;; 0755
    (call-with-output-file out-file
      (lambda (port)
        (format port "# Guix API (docstrings dump)\n\n")
        (for-each (lambda (name) (doc-module port name))
                  major-modules)))
    (format #t "Wrote ~a\n" out-file)))
Add the workflow
Add file → Create new file
Path: .github/workflows/build-api-docs.yml
Paste:
YAML

name: Build API docs from Guix docstrings (PDF)

on:
  workflow_dispatch:
  push:
    branches: [ main, master ]

jobs:
  api-docs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install deps (Guile, Guix, Pandoc, LaTeX)
        run: |
          sudo apt-get update
          # guix package is in Ubuntu repos; if this fails, see note below.
          sudo apt-get install -y guile-3.0 guix pandoc \
            texlive-latex-base texlive-latex-recommended \
            texlive-fonts-recommended texlive-latex-extra

      - name: Extract docstrings to Markdown
        run: |
          guile scripts/extract-docs.scm
          test -f build/guix-modules.md && head -n 20
build/guix-modules.md || true

      - name: Convert Markdown to PDF via pandoc
        run: |
          pandoc build/guix-modules.md \
            -V geometry:margin=1in \
            -V documentclass:article \
            -o build/guix-api-docs.pdf

      - name: Upload artifact
        uses: actions/upload-artifact@v4
        with:
          name: guix-api-docs
          path: build/guix-api-docs.pdf
Run it
Go to Actions → Build API docs from Guix docstrings (PDF) → Run workflow.
Download the artifact guix-api-docs.
Notes and pitfalls for Option B

If the “Install deps” step fails because the guix package isn’t found
on the runner image, try switching the runner to ubuntu-22.04 in the
workflow, or use Option A. Installing Guix from its installer requires
a privileged daemon and won’t work in GitHub Actions.
Some modules may fail to load (e.g., ones that need libguix/FFI); the
script will skip those and keep going.
Docstrings in Guix frequently use Texinfo markup; the resulting PDF
will show those literally (which is fine, just not as polished as the
official manual).
Which option should you pick?

Want a single, complete, nicely formatted PDF that documents major
modules? Use Option A.
Want a hackable, per-export dump of what’s documented in code right
now? Use Option B.
If you want, tell me which specific modules you care about and I’ll
tune the module list or split into one PDF per module.

Hi GPT-5. I'm on lmsys direct chat on an old android phone. I'd like
to make pdf format documentation of all the major guix modules maybing
using guile documentá, on this phone. Maybe with a github action?
Could you write the code to do this if needed and instruct me how?

Inputs are processed by third-party AI and responses may be inaccurate.

Re: [ot][spam]gpt-4 completions

Baffo 32