2026-04-01·9 min read·sota.io team

Deploy GNU Guile (Scheme) to Europe — Lisp on EU Infrastructure in 2026

Most languages separate code from data. Scheme does not.

In a Lisp-family language, program source code is written as data structures — lists, symbols, and atoms — that the language itself can read, manipulate, and generate. This property, called homoiconicity, means that writing a macro is the same operation as writing a function. The language has no separate preprocessor phase. Transformations on code are transformations on data, expressed in the same language, with the same tools.

This design decision, made by Gerald Jay Sussman and Guy L. Steele Jr. at MIT in 1975 when they designed Scheme, turns out to have profound consequences for auditability, correctness, and regulatory compliance. A codebase written in a homoiconic language can be analysed, transformed, and verified by tools written in that same language. Metadata, provenance information, and governance rules are not annotations bolted onto the side of the code — they are data structures that the program processes natively.

GNU Guile is the official Scheme implementation of the GNU Project and the GNU system's standard extension language. It is maintained today primarily by Andy Wingo at Igalia 🇪🇸 — a Spanish software cooperative based in La Coruña, Galicia — and Ludovic Courtès 🇫🇷 at INRIA Bordeaux. These two contributors represent a deep EU institutional commitment to Guile: Igalia is one of Europe's most significant open-source engineering firms, with major contributions to WebKit, V8, GCC, and the Linux kernel; INRIA is France's national research institute for digital science. On sota.io's German infrastructure, GNU Guile runs as a first-class EU-native language: European maintainers, European hosting, European jurisdiction.

Igalia and INRIA: The EU Maintainers of GNU Guile

Andy Wingo is the primary maintainer of GNU Guile and a partner at Igalia 🇪🇸 (La Coruña, Galicia, Spain). Founded in 2001, Igalia is a worker-owned cooperative of approximately 130 engineers that has become one of the most significant open-source companies in the world without venture capital or a proprietary product line. Igalia engineers implement new JavaScript features in V8 and SpiderMonkey. They implement new CSS and HTML features in WebKit and Blink. They maintain GNOME accessibility and internationalisation layers. They maintain GNU Guile.

Wingo has transformed GNU Guile into a modern language runtime: a native-code JIT compiler (using a custom register-based intermediate language), a garbage collector with precise roots, first-class continuations, a green-threading library (Fibers), and a WebAssembly compilation backend. Guile 3.0 (2020) delivers performance competitive with other dynamic language runtimes while retaining full R7RS Scheme compatibility.

Ludovic Courtès 🇫🇷 is a researcher at INRIA Bordeaux and the lead developer of GNU Guix — the functional package manager and GNU/Linux distribution written entirely in Guile Scheme. GNU Guix is deployed at major EU research institutions: the Max Planck Society 🇩🇪 runs Guix on HPC clusters; the Institut Pasteur 🇫🇷 in Paris uses Guix for bioinformatics reproducibility; Inria itself uses Guix for software provenance in research workflows. Every GNU Guix package definition is a Guile Scheme expression — a data structure that encodes the complete dependency graph of a software artifact, reproducible bit-for-bit across machines and time.

;; GNU Guile: the language GNU Guix is written in
;; This is a real GNU Guix package definition — pure Guile Scheme

(define-public guile-3.0
  (package
    (name "guile")
    (version "3.0.9")
    (source (origin
              (method url-fetch)
              (uri (string-append "mirror://gnu/guile/guile-"
                                  version ".tar.xz"))
              (sha256
               (base32
                "1qh3kqkk1pfsjfkbqc6blf5m59bj4dhkxqjwbr5wx1bkfz7dfg0"))))
    (build-system gnu-build-system)
    (synopsis "GNU Guile — official Scheme implementation of the GNU Project")))
;; Every GNU Guix package is a Guile data structure.
;; Provenance, hash, build instructions: all in the same language.
;; EU AI Act Art. 15: supply chain integrity as structured data.

The GNU Guix approach — encoding the entire software supply chain as Guile data structures — is a direct implementation of EU AI Act supply chain integrity requirements at the build system level.

GNU Guile as GNU Extension Language

GNU Guile is the official extension language of the GNU system. This means that Guile is the scripting layer for:

GnuCash — GNU accounting software used across EU SMEs and nonprofits; its business logic, reports, and tax rules are written in Guile Scheme
LilyPond — GNU music notation system used by EU conservatories and publishers; all engraving algorithms are written in Guile
GNU Make — can call Guile functions natively for complex build logic
GNU Debugger (GDB) — Guile is the extension language for GDB scripting since 7.3
GNU Emacs — Guile integration for extending the GNU editor

This breadth of deployment means Guile is not a niche research language — it is the scripting substrate of the GNU software stack running on millions of EU Linux servers. The choice to use Guile for new EU-native tooling is a choice to write in the same language as the system that runs beneath it.

Fibers: Concurrent Network I/O in Guile

Andy Wingo's Fibers library provides cooperative green-thread concurrency for GNU Guile. Fibers wraps Linux's epoll event loop with a Scheme continuation-based scheduler — each fiber is a lightweight coroutine that suspends itself during I/O and resumes when the kernel signals readiness. This model handles tens of thousands of concurrent connections on a single OS thread, with no callback hell and no async/await syntax overhead.

;; GNU Guile HTTP server using Fibers concurrency
;; Andy Wingo (Igalia 🇪🇸, La Coruña, Spain) — Fibers library

(use-modules (web server)
             (web request)
             (web response)
             (web uri)
             (fibers)
             (fibers channels)
             (ice-9 match))

;; Pure handler: request in, response out — no hidden state
(define (handle-request request body)
  (let ((path (uri-path (request-uri request))))
    (match path
      ("/health"
       (values (build-response #:code 200
                               #:headers '((content-type . (application/json))))
               "{\"status\":\"ok\",\"runtime\":\"guile\",\"region\":\"eu-central-1\"}"))
      ("/api/languages"
       (values (build-response #:code 200
                               #:headers '((content-type . (application/json))))
               (format #f "{\"count\":74,\"hub\":\"https://sota.io/blog/deploy-to-europe-all-languages\"}")))
      (_
       (values (build-response #:code 404
                               #:headers '((content-type . (application/json))))
               "{\"error\":\"not found\"}")))))

;; Start server with Fibers event loop (no OS thread per connection)
(run-fibers
 (lambda ()
   (run-server handle-request
               'http
               '(#:port 8080 #:addr #f))))

Fibers achieves concurrency through delimited continuations — a fundamental Scheme capability that allows any computation to be suspended and resumed. This is not a library feature grafted onto the language; it is a direct consequence of Scheme's first-class control flow primitives. The same mechanism that implements fibers can implement structured concurrency, async/await, backtracking search, and coroutines — all as Scheme libraries, without language changes.

The GDPR's Article 5(2) accountability principle requires that data controllers demonstrate compliance with data protection principles. In most languages, governance rules are expressed as configuration files, database records, or annotations — data formats that are separate from and interpreted by the program.

In Guile Scheme, governance rules are Scheme expressions. They are data structures that the program evaluates, but they can also be read, transformed, and audited by tools written in Guile. There is no translation layer between the policy description and its execution.

;; GDPR Art. 5(2) Accountability: governance rules as Guile data structures
;; Rules are data → auditable, transformable, provably complete

(define gdpr-retention-rules
  ;; Each rule is a list: (data-category retention-days basis article)
  '((health-data         365  "explicit-consent"  "Art. 9(2)(a)")
    (financial-records  2555  "legal-obligation"  "Art. 17(3)(b)")  ; 7 years
    (marketing-profiles   90  "legitimate-interest" "Art. 6(1)(f)")
    (session-tokens        1  "contract"          "Art. 6(1)(b)")
    (audit-logs         1825  "legal-obligation"  "Art. 30")))       ; 5 years

;; Query retention rules — same language as the rules
(define (get-retention data-category)
  (let ((rule (assq data-category gdpr-retention-rules)))
    (if rule (cadr rule) #f)))

;; Generate GDPR retention report — homoiconic: rules ARE the report
(define (retention-report)
  (map (lambda (rule)
         (match rule
           ((category days basis article)
            (format #f "~a: ~a days (~a) [~a]"
                    category days basis article))))
       gdpr-retention-rules))

;; DPO audit: rules are readable data, not buried in imperative code
(for-each display (retention-report))

A DPO reviewing this codebase sees the complete retention policy as a structured data literal — not dispersed across configuration files, not embedded in database procedures, not inferred from imperative code. The rules are data. Auditing them is reading a Guile list. Updating them is updating a Guile list. Verifying completeness is asking Guile to enumerate them.

Hygienic Macros and EU AI Act Article 10

GNU Guile implements R7RS hygienic macros — a macro system in which macro-generated code cannot accidentally capture variables from the surrounding scope, and in which the expansion is deterministic and auditable. Macros in Scheme are transformations from data (the macro call, as a list) to data (the expanded code, as a list), written in Scheme itself.

This property enables compile-time enforcement of data governance schemas — a direct implementation of EU AI Act Article 10 requirements for data quality in AI training pipelines.

;; EU AI Act Art. 10: data governance enforced at compile time via macros
;; Hygienic macros: expansion is deterministic and auditable

(define-syntax define-training-record
  (syntax-rules ()
    ;; Macro: generates a record type with mandatory provenance fields
    ;; Every training record MUST declare: source, consent-basis, collection-date
    ((_ name (field ...) #:provenance (source consent-basis collection-date))
     (begin
       ;; Generate record type with mandatory provenance
       (define (make-record field ... source consent-basis collection-date)
         (list 'name field ... source consent-basis collection-date))
       ;; Generate accessors with provenance always accessible
       (define (record-source r)        (list-ref r (+ (length '(field ...)) 1)))
       (define (record-consent-basis r) (list-ref r (+ (length '(field ...)) 2)))
       (define (record-date r)          (list-ref r (+ (length '(field ...)) 3)))))))

;; Define AI training record — provenance fields mandatory at compile time
(define-training-record medical-image
  (pixel-data width height modality label)
  #:provenance (source consent-basis collection-date))
;; Compile error if provenance fields are missing → EU AI Act compliance by design

Hygienic macros make it impossible to define a training record that omits provenance information — the macro expansion fails at compile time, before any data is processed. This is structural compliance with the EU AI Act's data quality requirements, enforced by the language's macro system rather than by runtime validation.

GNU Guix and EU AI Act Supply Chain Integrity

GNU Guix — written entirely in Guile Scheme by Ludovic Courtès 🇫🇷 and the Guix community — provides reproducible builds with cryptographic integrity. Every Guix package definition is a Guile data structure specifying exact source hashes, build instructions, and dependency closures. Given the same Guix expression, any machine produces a bit-for-bit identical binary output.

This is a direct implementation of EU AI Act Article 15 robustness requirements and NIS2 Article 21 supply chain security requirements. The entire dependency graph of an AI model's training environment can be expressed as a Guile data structure, committed to a repository, and reproduced exactly on EU infrastructure — with cryptographic proof that no dependency has been altered.

# GNU Guix: reproducible build for a Guile ML application
# Ludovic Courtès 🇫🇷 (INRIA Bordeaux) — GNU Guix lead developer

# guix.scm — the complete dependency graph as Guile data
cat guix.scm
# (use-modules (guix packages) (guix build-system guile))
# (packages->manifest
#   (list guile-3.0 guile-fibers guile-json guile-postgresql))

# Reproduce environment exactly — same hash on any EU server
guix environment --manifest=guix.scm

# Export environment with cryptographic closure
guix pack --format=docker --manifest=guix.scm
# → docker-pack.tar.gz (SHA256 deterministic)
# → EU AI Act Art. 15: supply chain provenance, bit-for-bit reproducible

Research groups at the Max Planck Society 🇩🇪 use Guix to share exact computational environments across sites — if a bioinformatics pipeline produces result X on a workstation in Berlin, it produces result X on an HPC cluster in Garching, provably. The Institut Pasteur 🇫🇷 in Paris uses Guix for the same reason in its genomics pipelines. This is not a theoretical property — it is deployed EU research infrastructure.

Deploying GNU Guile on sota.io

GNU Guile is packaged in every major Linux distribution and installs on Debian in a single command. The deployment path to sota.io is minimal:

Step 1 — Write a Guile HTTP server:

;; server.scm — GNU Guile HTTP service
(use-modules (web server)
             (web request)
             (web response)
             (web uri)
             (ice-9 match)
             (fibers))

(define (handler request body)
  (let ((path (uri-path (request-uri request))))
    (match path
      ("/health"
       (values (build-response #:code 200
                               #:headers '((content-type . (application/json))))
               "{\"ok\":true}"))
      (_
       (values (build-response #:code 404
                               #:headers '((content-type . (application/json))))
               "{\"error\":\"not found\"}")))))

(run-fibers
 (lambda ()
   (run-server handler 'http '(#:port 8080 #:addr #f))))

Step 2 — Containerise for sota.io:

FROM debian:bookworm-slim

RUN apt-get update \
    && apt-get install -y --no-install-recommends \
       guile-3.0 \
    && rm -rf /var/lib/apt/lists/*

# Install Fibers via guild (Guile's module installer)
RUN guile -c "(use-modules (fibers))" 2>/dev/null || \
    apt-get install -y --no-install-recommends guile-fibers

WORKDIR /app
COPY server.scm .

EXPOSE 8080
CMD ["guile", "server.scm"]

Step 3 — Deploy to EU infrastructure:

# Deploy GNU Guile backend to Germany via sota.io
sota login
sota init --name guile-backend --region eu-central-1
sota deploy

# Output:
# ✓ Build completed (guile:3.0 → Debian bookworm-slim)
# ✓ Deployed to fra1.sota.io (Frankfurt, Germany)
# ✓ GDPR: data residency EU enforced
# ✓ No CLOUD Act exposure (no US parent entity)
# ✓ URL: https://guile-backend.sota.io

With managed PostgreSQL:

;; Connect to sota.io managed PostgreSQL from Guile
(use-modules (dbi dbi))

(define db
  (dbi-open "postgresql"
            (getenv "DATABASE_URL")))
;; DATABASE_URL injected automatically by sota.io

(define (query-users)
  (dbi-query db "SELECT id, email FROM users WHERE active = true")
  (let loop ((row (dbi-get_row db)) (results '()))
    (if (not row)
        (reverse results)
        (loop (dbi-get_row db) (cons row results)))))

The Scheme Lineage in European Computer Science

Scheme was designed in 1975 at MIT. But its influence on European computer science has been deep and lasting:

Scheme (1975)               Sussman + Steele, MIT
    │
    ├── R7RS (2013)          European academic consensus
    │       ├── Guile         Andy Wingo 🇪🇸 (Igalia, La Coruña) + Ludovic Courtès 🇫🇷 (INRIA)
    │       ├── Racket        Matthias Felleisen (Northeastern) — EU academic influence
    │       ├── Chicken       Felix Winkelmann 🇩🇪 (German) — CHICKEN Scheme for C-output
    │       └── SRFI          srfi.schemers.org — EU contributors (Donovan Kolbly, Shiro Kawai)
    │
    ├── GNU Guix              Ludovic Courtès 🇫🇷 — reproducible builds (INRIA/Max Planck/Pasteur)
    │
    ├── Bigloo                Manuel Serrano 🇫🇷 (INRIA Sophia-Antipolis) — compiles to C/JVM/JS
    │
    └── MIT/GNU Scheme        Hans Aalbersberg, SICP — European CS curriculum worldwide

Manuel Serrano 🇫🇷 at INRIA Sophia-Antipolis maintains Bigloo — a Scheme compiler that targets C, JVM, and JavaScript. Bigloo is used in the French research community for embedded systems and language research. CHICKEN Scheme by Felix Winkelmann 🇩🇪 compiles Scheme to C, producing small native binaries used in embedded EU systems. The SRFI (Scheme Requests for Implementation) standardisation process has significant EU contributor participation across universities in Germany, the Netherlands, Sweden, and France.

The Scheme community is not large by industry standards, but it is deep: a disproportionate fraction of programming language theory research — algebraic effects (Plotkin 🇬🇧 Edinburgh, Pretnar 🇸🇮 Ljubljana), dependent types (Martin-Löf 🇸🇪, Coquand 🇫🇷), and continuations (Reynolds 🇺🇸 but primarily European academic lineage) — was influenced by or developed in conversation with Scheme's design. Deploying Guile on EU infrastructure is not nostalgia. It is deploying the substrate of four decades of European programming language research.

Why sota.io for GNU Guile on EU Infrastructure

GNU Guile is maintained by EU engineers (Igalia 🇪🇸, INRIA 🇫🇷). GNU Guix — written in Guile — is deployed on EU research infrastructure at Max Planck and Pasteur. The language's design properties (homoiconicity, hygienic macros, first-class continuations, reproducible build tooling) map directly onto EU regulatory requirements for auditability, data governance, and supply chain integrity.

sota.io closes the infrastructure gap. EU-native PaaS on German Hetzner hardware. GDPR-compliant by default: your data never leaves the EU, no US CLOUD Act jurisdiction, no transatlantic data transfers. Managed PostgreSQL with DATABASE_URL injected automatically. Zero DevOps: push a Dockerfile, get a URL, scale automatically.

# GNU Guile on sota.io: deploy the GNU extension language to EU infrastructure
sota login
sota init --name guile-service --region eu-central-1
sota deploy

# Output:
# ✓ Build: guile:3.0 on Debian bookworm-slim
# ✓ Region: Frankfurt, Germany (eu-central-1)
# ✓ GDPR: EU data residency enforced
# ✓ EU AI Act: Guix reproducible builds available
# ✓ Maintainers: Igalia 🇪🇸 (La Coruña) + INRIA 🇫🇷 (Bordeaux)
# ✓ URL: https://guile-service.sota.io

Andy Wingo at Igalia built Guile's JIT compiler and Fibers concurrency in Europe. Ludovic Courtès at INRIA built GNU Guix's reproducible infrastructure in France. sota.io runs their work where it belongs: on EU soil, under EU law, with the data minimisation, accountability, and supply chain integrity that GDPR and the EU AI Act demand.

Deploy your GNU Guile application to Europe today at sota.io. EU-native infrastructure, GDPR-compliant by default, managed PostgreSQL, zero DevOps overhead.