Deploy Caml Light to Europe — Xavier Leroy 🇫🇷 (INRIA Rocquencourt 1991), the Language That Made ML Portable, on EU Infrastructure in 2026

In 1991, a researcher at INRIA Rocquencourt — a French national laboratory tucked in the forest near Versailles — rewrote an entire programming language runtime from scratch. The goal was audacious: take ML, a language that required a Unix workstation to run, and make it execute on a 286 PC with 640 kilobytes of RAM. The result was Caml Light. The runtime he designed — the ZINC abstract machine — runs inside every OCaml binary compiled today, 35 years later.

Caml Light was created by Xavier Leroy 🇫🇷 and Damien Doligez 🇫🇷 at INRIA Rocquencourt (Institut National de Recherche en Informatique et en Automatique) in 1991. It was the direct predecessor to OCaml, and through OCaml to F#, Reason/ReScript, and the entire ecosystem of industrial ML-family languages that runs in production at Jane Street London, BNP Paribas Paris, and hundreds of EU financial and safety-critical systems today.

The history of Caml Light is the history of how EU academic computer science became industrial infrastructure — a story that runs from a research forest near Versailles to the trading floors of Canary Wharf.

Xavier Leroy and INRIA Rocquencourt

Xavier Leroy 🇫🇷 studied at the École Normale Supérieure (Paris) — one of France's elite grandes écoles — and joined INRIA Rocquencourt as a researcher in the early 1990s. INRIA (founded 1967 under the French Ministry of Research and the Ministry of Economy) is France's national institute for computer science research, operating eight research centres across France. The Rocquencourt site, in Le Chesnay-Rocquencourt near Versailles in the Île-de-France region, was INRIA's founding location — a château estate that the French state converted into a computing research institute.

Leroy's contributions to computer science span four decades: Caml Light (1991), OCaml (1996, co-designed with Didier Rémy and Jérôme Vouillon at INRIA), and CompCert (2006) — the first formally verified optimising C compiler. In 2017, he was appointed to the Collège de France as Chair of Software Science — the most prestigious scientific appointment in France, a permanent professorship held by one person at a time in each scientific domain. Previous occupants of computing-adjacent chairs include Gérard Berry 🇫🇷 (Esterel, synchronous programming) and other luminaries of French computer science.

In 2023, Xavier Leroy received the ACM Software System Award — one of computing's highest honours — for OCaml, jointly with Damien Doligez, Alain Frisch, Jacques Garrigue, Didier Rémy, and Jérôme Vouillon. The award citation notes OCaml's "lasting influence on the design and implementation of programming languages and their type systems."

The CAML Family: From Categorical Machine to Industrial Standard

The story of Caml Light begins with a different language — one that was too complex to spread.

CAML (Categorical Abstract Machine Language) was developed at INRIA starting in 1987 by Guy Cousineau 🇫🇷, Luca Cardelli 🇮🇹, Michel Mauny 🇫🇷, and others. CAML was built on the Categorical Abstract Machine (CAM) — an elegant theoretical model derived from category theory and the lambda calculus. The implementation was sophisticated but heavy: it required substantial memory, ran only on Unix workstations, and was difficult to port.

CAML demonstrated that ML-style type inference could be implemented efficiently, but it could not reach the broad research and educational community. In 1991, Leroy and Doligez rebuilt it entirely.

Caml Light (1991) introduced three architectural innovations that changed everything:

1. The ZINC Abstract Machine — Leroy designed a new bytecode virtual machine called ZINC (ZINC Is Not a CAM). Unlike the CAM, ZINC was designed for call-by-value semantics with efficient currying: multi-argument functions are compiled with arity checking, avoiding the thunk-per-application overhead of naive currying. The ZINC machine was extraordinarily compact — the entire runtime fit in under 40KB of C code.

2. Portable bytecode compilation — CAML Light compiled to ZINC bytecode, which could run on any machine for which the small C-language interpreter was compiled. In 1991, this meant 286 PCs running MS-DOS, Macintosh, Amiga, Atari ST. ML came to personal computers for the first time.

3. Separate compilation — Caml Light introduced a proper module system with separate compilation of .ml source files and .mli interface files. Each compilation unit specified its public interface explicitly. This design, carried forward into OCaml, became one of ML's distinguishing features for large-scale software engineering.

The ZINC machine was so well-designed that when OCaml was built on top of Caml Light in 1996, it kept ZINC — with extensions for the new object system. Every OCaml bytecode binary running today executes on Leroy's 1991 virtual machine design.

CAML (1987)       Guy Cousineau + team, INRIA Rocquencourt 🇫🇷
    CAM: Categorical Abstract Machine
    Heavy runtime, Unix workstations only

Caml Light (1991)  Xavier Leroy + Damien Doligez, INRIA Rocquencourt 🇫🇷
    ZINC: ZINC Is Not a CAM
    Bytecode VM, runs on 286 PC, 640KB RAM
    Separate compilation, .ml/.mli interface files

OCaml (1996)       Didier Rémy + Jérôme Vouillon + Xavier Leroy, INRIA 🇫🇷
    ZINC extended with object heap representation
    Native code compiler (AMD64, ARM64, RISC-V)
    Polymorphic variant types, first-class modules

F# (2005)          Don Syme 🇬🇧, Microsoft Research Cambridge 🇬🇧
    OCaml semantics on .NET CLR
    Computation expressions (do-notation generalised)
    Used at Jane Street 🇬🇧 London for trading infrastructure

Reason/ReScript (2016) Jordan Walke, Facebook — OCaml AST, JS syntax
js_of_ocaml        INRIA 🇫🇷 — compiles OCaml bytecode to JavaScript

CompCert: Formal Verification as EU Regulatory Infrastructure

In 2006, Xavier Leroy and his team at INRIA released CompCert — a formally verified C compiler written in and verified with the Coq proof assistant (Rocq). CompCert is the first — and still the only — production-grade optimising C compiler whose correctness has been mathematically proved: given a valid C source program, the assembly output is guaranteed to compute exactly what the source semantics specify. No miscompilations. Provably.

CompCert is certified at DO-178C Level A — the highest avionics software certification level — and used in:

• Airbus 🇫🇷 flight control software (A380/A350 primary flight computers)
• MBDA 🇫🇷🇬🇧 missile guidance systems
• Safety-critical medical device firmware (IEC 62304 Class C)

The EU AI Act (Regulation 2024/1689), entering full effect in 2026, requires that high-risk AI systems have documented and tested software processes under Article 9 (Risk Management) and Article 15 (Accuracy, Robustness and Cybersecurity). CompCert, derived from Xavier Leroy's Caml Light runtime foundations, represents precisely the kind of formally verified software infrastructure the EU AI Act's risk management requirements envision.

INRIA: France's National Computing Research Infrastructure

INRIA was founded in 1967 as the first French national research institute specifically for computing. Operating under the French Ministry of Higher Education and Research, INRIA today employs over 3,800 researchers across eight centres:

• INRIA Paris (successor to Rocquencourt): ML/Caml/OCaml, formal verification, type theory
• INRIA Grenoble: Lustre (Halbwachs), synchronous programming, control systems
• INRIA Sophia-Antipolis: Esterel (Gérard Berry), SCADE, reactive systems
• INRIA Bordeaux: LHS Guix reproducible builds (Ludovic Courtès)
• INRIA Rennes: SIGNAL (Pierre Le Guernic), IRISA, Brittany research cluster
• INRIA Nancy: Alice ML, distributed systems (DFKI collaboration with Saarbrücken 🇩🇪)

INRIA Rocquencourt is where ML became portable. INRIA Sophia-Antipolis is where synchronous programming became industrial (Airbus fly-by-wire). INRIA Grenoble is where real-time control systems got formally specified. The geography of INRIA research is a map of the EU software safety infrastructure that governs aerospace, nuclear, automotive, and defence today.

EU Regulatory Angles: Type Safety as Compliance

GDPR Art. 25 — Data Protection by Design: Caml Light's Hindley-Milner type system enforces data handling contracts at compile time. A function that processes personal data takes a typed parameter; the type checker prevents processing the wrong category of data. Type-safe ML programs cannot accidentally pass medical data to a logging function that expects strings — the category distinction is enforced by the compiler. This is GDPR data minimisation at the language level.

GDPR Art. 5(2) — Accountability: ML's type system makes data transformations explicit and traceable. Every function's type signature is a documented contract. Combined with OCaml's module system (introduced in Caml Light as .mli interface files), every system boundary is specified formally — an audit trail by language design.

EU AI Act Art. 9 — Risk Management Systems: CompCert's formally verified compilation eliminates the risk class of miscompilation in safety-critical software. For high-risk AI systems under the EU AI Act, formally verified compilation is one concrete mechanism for demonstrating the "appropriate level of accuracy, robustness and cybersecurity" required by Article 15.

NIS2 Directive — Critical Infrastructure Security: Jane Street 🇬🇧 London — one of Europe's largest algorithmic trading firms — runs its entire trading infrastructure in OCaml. The ZINC machine processes billions of financial transactions in EU markets. NIS2's requirements for "resilience" and "supply chain security" are met, in part, by the mathematical properties of OCaml's type system: no null pointer exceptions, no buffer overflows, no data races in pure code.

Jane Street London: Caml Light's Industrial Heir

Jane Street operates one of the world's largest OCaml codebases from its London 🇬🇧 office in Canary Wharf. Jane Street chose OCaml for its trading systems because:

1. Type safety at scale — millions of lines of code with no null pointer exceptions by design
2. Performance — OCaml's native compiler (built on ZINC's foundations) generates code competitive with C++
3. Expressiveness — algebraic types and pattern matching model financial instruments naturally
4. Refactorability — the type checker catches breaking changes across a million-line codebase

Jane Street has contributed back: Core (a comprehensive standard library), Async (cooperative concurrency), ppx (preprocessor extensions), and dune (the dominant OCaml build system). These tools are used by the EU OCaml community widely.

Jane Street London operates under MiFID II (Markets in Financial Instruments Directive II) and EMIR (European Market Infrastructure Regulation) — EU financial regulations with strict requirements for algorithm documentation, risk management, and operational resilience. OCaml's type system and formal semantics are part of Jane Street's compliance infrastructure.

Running Caml Light's Legacy on EU Infrastructure

Caml Light is available as a historical artifact, but its successor — OCaml — is a fully maintained, production-grade language. OCaml carries Caml Light's ZINC bytecode VM, its .ml/.mli module system, and its Hindley-Milner type inference forward into 2026.

On sota.io, you deploy OCaml on EU infrastructure in Germany:

# Caml Light's legacy (OCaml) on sota.io: EU-native deployment
sota login
sota init --name caml-heritage-api --region eu-central-1
sota deploy

# Output:
# ✓ Build: OCaml 5.2 (ZINC machine — Leroy 1991, INRIA Rocquencourt)
# ✓ Deployed to fra1.sota.io (Frankfurt, Germany)
# ✓ GDPR: data residency EU enforced
# ✓ Type safety: Hindley-Milner — no null pointers, no data races
# ✓ URL: https://caml-heritage-api.sota.io

A minimal Dream (OCaml HTTP framework) server that demonstrates Caml Light's .mli interface discipline:

(* server.mli — public interface, Caml Light's invention (1991) *)
val start : port:int -> unit Lwt.t
val handle_gdpr_request : Dream.request -> Dream.response Lwt.t

(* server.ml — implementation, only what's in .mli is visible *)
let handle_gdpr_request request =
  (* Hindley-Milner: type of subject_id enforced at compile time *)
  let subject_id = Dream.param request "id" in
  let%lwt data = Database.fetch_subject_data subject_id in
  (* GDPR Art. 5(2): transformation is typed, traceable *)
  Dream.json (Yojson.Safe.to_string data)

let start ~port =
  Dream.run ~port
  @@ Dream.router [
    Dream.get "/gdpr/subject/:id" handle_gdpr_request;
  ]

The .mli interface file is Caml Light's 1991 contribution: explicit separation of specification from implementation, enforced by the compiler. Every OCaml module boundary in 2026 reflects Leroy's architectural decision made on a 286 PC in a research forest near Versailles.

Caml Light's Technical Legacy in Numbers

Why sota.io for Caml-Heritage Applications

sota.io runs OCaml — Caml Light's direct successor — on EU infrastructure in Frankfurt, Germany. INRIA built the language on French soil; sota.io deploys it on German soil. Data never leaves the EU. No CLOUD Act exposure. GDPR-compliant by construction.

sota deploy --name ocaml-backend --region eu-central-1

# ✓ OCaml 5.2 — ZINC machine (Leroy, INRIA Rocquencourt 1991)
# ✓ Deployed: fra1.sota.io (Frankfurt, Germany 🇩🇪)
# ✓ GDPR: data residency EU enforced
# ✓ Managed PostgreSQL 17 included
# ✓ Type-safe: no null pointers, no buffer overflows
# ✓ MiFID II / DORA ready: traceable, auditable, formally specified

Xavier Leroy designed Caml Light to run on hardware that no one uses anymore, with a runtime so elegant it still runs inside modern OCaml compilers. INRIA built the language in a Versailles forest and released it to the world. In 2026, on sota.io's German infrastructure, every .mli interface and every algebraic type you write executes on Leroy's ZINC machine — on European soil, under European law, with the correctness and auditability the EU demands.

Deploy your OCaml application to Europe today at sota.io. EU-native infrastructure, GDPR-compliant by default, managed PostgreSQL, zero DevOps. See also: Deploy OCaml to Europe →, Deploy Standard ML to Europe →, Deploy F# & Giraffe to Europe →, Deploy Isabelle to Europe →, Deploy Rocq/Coq to Europe →