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

Deploy Bigloo to Europe — Manuel Serrano 🇫🇷 (INRIA Sophia-Antipolis 1992), the Scheme Compiler That Compiles to Native, JVM, and WebAssembly, on EU Infrastructure in 2026

In 1992, a French researcher at INRIA Sophia-Antipolis on the French Riviera built a Scheme compiler with an unusual ambition: one language, multiple compilation targets. The result was Bigloo — a Scheme implementation that produces native C-compiled binaries, JVM bytecode, and WebAssembly from a single Scheme codebase. More than thirty years later, Bigloo is still actively maintained, still adding new targets, and still the foundation of a multi-tier web programming framework that puts the same Scheme code on server and client simultaneously.

Bigloo was created by Manuel Serrano 🇫🇷 at INRIA Sophia-Antipolis (Institut National de Recherche en Informatique et en Automatique, Sophia-Antipolis campus, Alpes-Maritimes, French Riviera) in 1992. The name is a portmanteau of BIG and LOGO — a deliberate echo of the Scheme heritage through Logo, both languages descended from LISP. Bigloo compiles R7RS Scheme (and earlier standards) to three primary backends: C (producing native machine code via gcc or clang), JVM (producing Java bytecode), and JavaScript/WebAssembly (enabling browser-side execution). The same Scheme source compiles to all three targets with consistent semantics.

INRIA Sophia-Antipolis: France's Silicon Riviera Programming Language Cluster

INRIA (Institut National de Recherche en Informatique et en Automatique) is France's national research institute for digital science. Its Sophia-Antipolis campus, founded in 1983 near Nice and Cannes on the French Riviera, became the European equivalent of a programming language research cluster. The languages and tools that emerged from Sophia-Antipolis:

France joined the European Communities in 1957 (founding member). INRIA research is funded through EU Framework Programmes (ESPRIT, FP5–FP7, Horizon 2020, Horizon Europe). The programming languages that emerged from INRIA constitute a significant fraction of EU safety-critical infrastructure: Airbus A320/A380/A350 fly-by-wire systems (Lustre+Esterel via SCADE), formally verified software (CompCert+Coq), and the financial sector's functional programming (OCaml at Jane Street London and BNP Paribas Paris).

Sophia-Antipolis itself is Europe's largest science and technology park (founded 1969), hosting IBM 🇺🇸, Texas Instruments 🇺🇸, SAP 🇩🇪, Amadeus IT 🇪🇸, and dozens of EU research centres alongside INRIA. It is listed as a EU Smart Specialisation Strategy site for digital innovation.

Bigloo's Multi-Target Architecture

The defining characteristic of Bigloo is its unified frontend, multiple backends design. One R7RS Scheme program compiles to:

Bigloo Scheme Source (.scm)
    R7RS-compliant syntax + Bigloo extensions
    Pattern matching (match-case)
    Module system (module declarations)
    Typed annotations (optional)

        ┌─────────────┬──────────────┬─────────────────┐
        ▼             ▼              ▼
   C Backend      JVM Backend    JavaScript/WASM Backend
   (bigloo -c)   (bigloo -jvm)   (bigloo -js / -wasm)
        │             │              │
        ▼             ▼              ▼
  Native binary  Java bytecode  Browser / Node.js / WASM
  (fast startup) (JVM ecosystem) (isomorphic web)
  sota.io Docker  sota.io JVM     sota.io static + server

C backend: Bigloo compiles to C and then invokes gcc or clang to produce native machine code. The generated C is not hand-written-style C — it is optimised output designed for further compiler optimisation. The result is native binaries with competitive performance. Bigloo uses Boehm GC (Hans Boehm 🇺🇸, conservative garbage collector widely used in production) for memory management in the C backend.

JVM backend: Bigloo can target the JVM, producing Java bytecode runnable on any Java Virtual Machine. This enables Bigloo programs to interoperate with the vast Java ecosystem — using Java libraries directly from Scheme code.

JavaScript/WebAssembly backend: The most distinctive feature of recent Bigloo. When combined with the HOP framework, Bigloo compiles Scheme to JavaScript for browser execution, enabling the same language on server and client. The WASM backend extends this to WebAssembly, enabling Scheme in performance-sensitive browser contexts.

Tail-call optimisation: Bigloo implements proper tail calls as required by the R7RS Scheme standard. Tail-recursive functions execute in constant stack space — essential for the recursive programming style Scheme encourages. Bigloo's C backend compiles tail calls to C tail calls, which most C compilers then optimise to jumps.

Hygienic macros: Bigloo supports syntax-rules hygienic macros from R7RS, plus its own define-expander system for non-hygienic macros when needed. Macros expand at compile time, enabling zero-cost domain-specific languages embedded in Scheme.

HOP: Isomorphic Web Programming in Scheme

The most production-visible application of Bigloo is HOP (Higher-Order Programming for the Web), also created by Manuel Serrano at INRIA Sophia-Antipolis and the Université Côte d'Azur.

HOP is an isomorphic web programming framework: the same Scheme source code runs on both server and client. The server-side code handles HTTP requests and database access. The client-side code handles DOM manipulation and browser events. Both are written in Scheme; the HOP compiler decides which parts compile to native server code and which compile to JavaScript for the browser.

;; HOP isomorphic web application (server + client in one file)
(import [hop :hss])

;; Server-side service (compiled to native Bigloo)
(define-service (counter-increment req)
  (let ([count (get-session-value req 'count 0)])
    (put-session-value! req 'count (+ count 1))
    (+ count 1)))

;; Client-side event handler (compiled to JavaScript)
(define (on-click-handler button-id)
  (~
    (let ([result (with-hop (counter-increment))])
      (dom-set-inner-html! button-id
        (string-append "Clicked " result " times")))))

;; Shared HTML template (renders on server, events on client)
(define (make-counter-page)
  (<HTML>
    (<HEAD> (<TITLE> "HOP Counter"))
    (<BODY>
      (<BUTTON>
        :id "counter-btn"
        :onclick (on-click-handler "counter-btn")
        "Click me"))))

The ~ (tilde) operator in HOP marks code that executes on the client side. Everything outside ~ runs on the server. The compiler partitions the program automatically, generating native Bigloo code for the server parts and JavaScript for the client parts.

HOP has been used for:

Deploying Bigloo on sota.io

Bigloo applications deploy to sota.io as Docker containers. The C backend produces self-contained native binaries with minimal runtime dependencies:

# Build stage: compile Bigloo Scheme to native binary
FROM debian:bookworm-slim AS builder

# Install Bigloo from Debian repositories
RUN apt-get update && apt-get install -y \
    bigloo \
    gcc \
    make \
    libgc-dev \
    && rm -rf /var/lib/apt/lists/*

# Copy Scheme source
WORKDIR /app
COPY src/ ./src/
COPY Makefile .

# Compile to native binary
RUN make build-native

# Runtime stage: minimal image
FROM debian:bookworm-slim AS runtime
RUN apt-get update && apt-get install -y \
    libgc1 \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY --from=builder /app/build/server ./server

EXPOSE 3000
CMD ["./server"]

A minimal Bigloo HTTP server using the web library:

;; server.scm — Bigloo HTTP server
(module server
  (import (web "bigloo-web"))
  (main main))

(define (handle-request req)
  (let ([path (http-request-path req)])
    (cond
      [(string=? path "/health")
       (http-response 200 "OK" "application/json"
         "{\"status\": \"healthy\", \"runtime\": \"bigloo-native\"}")]
      [(string=? path "/api/greet")
       (let ([name (http-query-param req "name" "World")])
         (http-response 200
           (string-append "{\"greeting\": \"Hello, " name "!\"}")
           "application/json"))]
      [else
       (http-response 404 "Not Found" "text/plain" "404 Not Found")])))

(define (main argv)
  (let ([port (string->integer
                (or (getenv "PORT") "3000"))])
    (display (string-append "Bigloo server on port "
               (number->string port) "\n"))
    (http-server-start port handle-request)))

For JVM deployment (useful for Java ecosystem integration):

FROM eclipse-temurin:21-jre-alpine AS runtime

WORKDIR /app
COPY build/server.jar ./

ENV PORT=3000
EXPOSE 3000
CMD ["java", "-jar", "server.jar"]

# sota.io configuration
services:
  - name: bigloo-api
    type: web
    dockerfile: Dockerfile
    envVars:
      - name: PORT
        value: "3000"
      - name: BIGLOO_TARGET
        value: "native"    # or "jvm" for JVM backend
    resources:
      memory: 128MB        # Native Bigloo binaries are small
      cpu: 0.25

Manuel Serrano: Three Decades at INRIA

Manuel Serrano 🇫🇷 is a senior researcher (Directeur de Recherche) at INRIA, currently at the INRIA Sophia-Antipolis Méditerranée research centre and professor at the Université Côte d'Azur (Nice). His research career spans the full lifecycle of Bigloo:

Université Côte d'Azur (UCA) was created in 2015 as part of France's IDEX (Initiative d'Excellence) programme — the French government's initiative to create world-class research universities. UCA received IDEX status in 2016, bringing together previously separate institutions in the Nice-Sophia Antipolis area into a single world-class research university. Serrano's work at UCA continues to receive EU Horizon Europe funding.

The Bigloo project has maintained continuous development for over 30 years — rare in programming language history. Most research languages die when their creator moves on; Bigloo has survived five decades of computing paradigm shifts from workstations to cloud to WebAssembly.

EU Regulatory Angles

GDPR Article 25 — Data Minimisation by Design: Scheme's functional core encourages stateless computation — pure functions from inputs to outputs with no implicit side effects. A Bigloo Scheme service that processes personal data can be structured as a pipeline of pure functions: (process-pii data) → (anonymise result) → (store sanitised). The language's lexical scoping (closures capture only explicitly listed bindings) prevents accidental PII leakage through shared mutable state. The compiler's strict module system ensures that data processing functions are isolated in modules with explicit import/export boundaries.

GDPR Article 5(1)(f) — Confidentiality and Integrity: Bigloo's memory model uses the Boehm conservative garbage collector, which does not expose freed memory to subsequent allocations. There is no manual free() — no use-after-free vulnerabilities, no buffer overruns from Scheme code (the C backend bounds-checks string and vector accesses). GDPR requires "appropriate technical measures" for data security; memory-safe languages reduce the attack surface available to exploit memory corruption.

EU AI Act Article 10 — Data Governance: Bigloo's hygienic macros enable compile-time enforcement of data governance rules. A macro system can be designed to reject code that accesses PII outside explicitly audited pipeline steps — enforcing data governance at the language level, before runtime, and checkable in EU AI Act conformity assessments.

NIS2 Directive — Critical Infrastructure Security: Scheme's emphasis on pure functions and immutable data structures eliminates entire classes of concurrency vulnerabilities. Race conditions require shared mutable state; Scheme programs that avoid mutation have no race conditions by construction. NIS2 requires "appropriate and proportionate technical measures" for cybersecurity — languages that eliminate vulnerability classes by design satisfy this requirement architecturally.

EU Chips Act 2023 (€43 billion): Bigloo compiles to native code (via C) and WebAssembly, both important targets for embedded EU semiconductor design. The WebAssembly backend enables Bigloo-written firmware to run on WASM-capable embedded processors — an emerging target as EU semiconductor manufacturers (STMicroelectronics 🇫🇷🇮🇹, NXP 🇳🇱, Infineon 🇩🇪) add WASM runtimes to their microcontrollers.

Scheme Heritage and the Lisp Family

Bigloo implements Scheme, a dialect of Lisp (LISt Processing) designed by Guy Steele 🇺🇸 and Gerald Jay Sussman 🇺🇸 at MIT in 1975. Scheme's minimalist design philosophy — small core, powerful primitives, rigorous semantics — contrasts with Common Lisp's kitchen-sink approach. Key Scheme design principles:

Lexical scoping: Variables are resolved by the textual structure of the program, not the dynamic call stack. This enables closures (functions that capture their environment) and makes programs more predictable. Every modern language uses lexical scoping; Scheme was one of the first to make it the exclusive scoping model.

Proper tail calls: A tail call (the last operation before a function returns) must execute in constant stack space. This enables recursive programs to run in constant memory — a recursive loop is as efficient as an iterative loop. R7RS mandates proper tail calls for all Scheme implementations.

First-class continuations (call/cc): Scheme's call-with-current-continuation captures the current execution context as a first-class value. This enables coroutines, cooperative multitasking, exception handling, and backtracking — all implementable as libraries without language-level support. Peter Landin's J-operator (#116 ISWIM, 1965) was the theoretical predecessor; Scheme's call/cc (1975) made it practical.

Hygienic macros: Scheme macros expand without polluting the lexical scope of the expansion site. The syntax-rules system (introduced in R5RS, 1998) guarantees that macro-introduced bindings do not capture user-visible identifiers — the hygiene condition. This makes Scheme macros composable in a way that Common Lisp or C preprocessor macros are not.

The R7RS standard (2013) is the current Scheme standard, supported by Bigloo. The lineage through EU research:

LISP (John McCarthy 🇺🇸, MIT, 1958)
  └─ Scheme (Steele + Sussman 🇺🇸, MIT, 1975)
        ├─ GUILE (Scheme) (#79 in this series)
        │   Andy Wingo 🇪🇸 (Igalia, La Coruña) + Ludovic Courtès 🇫🇷 (INRIA Bordeaux)
        │   GNU Guix reproducible builds at Max Planck Society 🇩🇪 + Institut Pasteur 🇫🇷
        │
        ├─ Bigloo (Manuel Serrano 🇫🇷, INRIA Sophia-Antipolis, 1992) — this post
        │   Native/JVM/WASM backends. HOP isomorphic web framework.
        │   Université Côte d'Azur (IDEX 2016, EU Horizon Europe)
        │
        └─ R7RS (2013 standard, international committee)
              Portable Scheme code runs on Guile, Bigloo, Chicken Scheme, Chez Scheme

See Also

Why sota.io for Bigloo Deployments

sota.io is the EU-native PaaS built for developers who need European infrastructure — not as a compliance checkbox, but as a technical requirement.

For Bigloo specifically:

EU infrastructure as a technical guarantee:

sota.io runs on German infrastructure. Your Bigloo service, your database, and your data stay in Europe.

# Deploy a Bigloo application to sota.io
sota deploy --region eu-central-1 --runtime bigloo-native

# Or via Docker with the C backend:
docker build -t bigloo-app . && sota deploy --image bigloo-app

# JVM backend:
docker build -f Dockerfile.jvm -t bigloo-jvm . && sota deploy --image bigloo-jvm