sota.io
2026-04-11·8 min read·sota.io team

Deploy Pliant to Europe — Hubert Tonneau 🇫🇷 (1994), the Self-Extending Language That Compiles to Native Code, on EU Infrastructure in 2026

Most programming languages are built with a fixed syntax. You learn the keywords, the operators, the statement forms — and they do not change. Pliant takes a different approach: it is a language that can extend its own syntax from within the language itself. A Pliant programmer can define new statement types, new control flow constructs, and new operator semantics that the compiler then understands as first-class syntax — not as macros over an existing syntax, but as genuine additions to the language.

Pliant was created by Hubert Tonneau 🇫🇷 in France, with development beginning around 1994 and the first public release in 1999. It compiles to native machine code, supports both procedural and functional styles, and was used by Tonneau to construct FullPliant — a complete self-hosting environment including an HTTP server, a database abstraction layer, and a template rendering engine, all written in Pliant itself.

The language is obscure by contemporary standards. It never attracted a large community. But its design contains ideas about extensible compilation that remain technically remarkable: a language that treats its own parser as a first-class extension point, written by a single French developer, compiled to native binaries, running on Linux since the late 1990s.

Hubert Tonneau and the FullPliant Vision

Hubert Tonneau 🇫🇷 was a French software engineer who became dissatisfied with the division between systems programming languages (C, C++) and high-level languages (Lisp, Python). His diagnosis: existing languages forced a choice between control (C gives you memory layout, calling conventions, inline assembly) and expressiveness (Lisp gives you homoiconic macros, dynamic dispatch, garbage collection). No language offered both without compromise.

Pliant was his answer. Its design goals:

Pliant design lineage:
  C (Ritchie, Bell Labs, 1972) — native compilation, manual memory
    ↓ reaction against: no extensibility, fixed syntax
  Lisp (McCarthy, MIT, 1958) — homoiconic macros, dynamic everything
    ↓ reaction against: no native compilation, GC overhead
  Forth (Moore, 1970) — extensible vocabulary, stack-based, native
    ↓ partial inspiration: user-defined words as language extensions

  Pliant (Tonneau 🇫🇷, 1994) — extensible syntax + native compilation + unified
    FullPliant: HTTP server + DB layer + templates, all in Pliant

The FullPliant system demonstrated the vision in practice. A FullPliant installation included:

All of these were written in Pliant and compiled with the Pliant compiler. The result was a self-contained web application environment that predated frameworks like Rails, Django, and Express by years — built not by a university or a corporation, but by a single French developer working outside the academic mainstream.

The Pliant Language

Pliant's syntax is unusual. It uses indentation for block structure (like Python) but with a very different semantic model. Function calls use a postfix-influenced style. The language is statically typed at the core but allows dynamic extension points.

# Basic Pliant: function definition and types
function greet name -> greeting
  arg Str name ; arg_w Str greeting
  greeting := "Bonjour, " + name + "!"

# Calling the function
var Str result
greet "Europa" -> result
console result eol
# Output: Bonjour, Europa!

Key syntactic elements:

The type system uses primitive types (Int, Str, Float, Bool) and allows definition of structured types:

# Pliant: structured types and methods
type Server
  field Str host
  field Int port
  field Bool running

function server_start s
  arg_rw Server s
  s running := true
  console "Starting server at " + s:host + ":" + (string s:port) eol

# Instantiate and use
var Server srv
srv host := "0.0.0.0"
srv port := 8080
server_start srv

The : operator accesses fields (s:host — field host of variable s). This is Pliant's notation for member access, distinct from the . used in most contemporary languages.

Extensible Syntax — Pliant's Core Innovation

The feature that distinguishes Pliant from nearly every other compiled language is its meta system. A Pliant programmer can define new statement forms that the compiler understands as if they were built-in syntax.

# Defining a new meta-construct: 'repeat...times'
meta repeat
  arg Int count
  the_body
  var Int i
  i := 0
  while i < count
    the_body
    i := i + 1

# Now 'repeat' is a first-class statement:
repeat 5
  console "Hello from EU" eol
# Output: Hello from EU (printed 5 times)

In this example, meta repeat defines a new syntactic construct. The the_body placeholder captures the indented block that follows the repeat N call. The compiler, when it encounters repeat 5, expands this to the while loop defined in the meta body — at compile time, as native code.

This is not a preprocessor macro. The meta body has full access to the compiler's type system and code generation. A meta-construct can:

# Meta with type-dependent behaviour
meta safely_divide
  arg Num a b result
  if b = 0
    result := 0
  else
    result := a / b

# Used like a built-in operator:
var Float x
safely_divide 10.0 3.0 x
console (string x) eol
# Output: 3.333...

safely_divide 10.0 0.0 x
console (string x) eol
# Output: 0 (division by zero handled at language level)

The practical consequence: Pliant programmers built domain-specific sub-languages within Pliant. The HTTP server layer defined new statement types for routing and request handling. The database layer defined SQL-like constructs that compiled to native database calls. These were not libraries in the conventional sense — they were extensions to the language itself.

FullPliant: A Self-Hosting Web Stack

The most concrete demonstration of Pliant's design was the FullPliant environment. By the early 2000s, Tonneau had built:

FullPliant architecture:

  pliant compiler (Pliant → native x86/x86-64)
    ↓ compiles
  pliant runtime (memory allocator, GC-optional, I/O)
    ↓ provides
  http server (TCP/IP stack in Pliant, HTTP/1.1 parser, connection pool)
    ↓ serves
  page engine (template system: HTML + Pliant embedded expressions)
    ↓ queries
  sql layer (PostgreSQL and SQLite bindings, query builder in Pliant syntax)
    ↓ stores data in
  PostgreSQL / SQLite

A FullPliant web application was structured as:

# FullPliant HTTP handler (simplified)
http_handler "/api/hello"
  arg Str name
  page_response
    html_tag "200 OK"
    content
      "Bonjour, " + name + " — from EU infrastructure"

# FullPliant database query
sql_query "SELECT id, name FROM users WHERE region = 'EU'"
  loop
    var Int user_id
    var Str user_name
    sql_field user_id user_name
    console user_id " " + user_name eol

The http_handler, page_response, html_tag, and sql_query constructs are all Pliant metas — extensions to the language defined in the FullPliant library, compiled to native code, with no runtime interpretation overhead.

This predates the convention of web frameworks by years. Rails launched in 2004. Django in 2005. Express.js in 2010. FullPliant in 2000. A single French developer, using an extensible compiled language, had built a self-hosting web stack before the term "web framework" was commonplace.

EU Origin and GDPR Implications

Pliant's French origin places it squarely in the European software tradition. Hubert Tonneau 🇫🇷 developed Pliant outside the academic pipeline (no MIT, no Stanford, no Bell Labs backing) — an independent European software developer building a full programming environment with novel design ideas.

The FullPliant HTTP server and database layer run as a single native binary with minimal dependencies. For GDPR compliance, this architecture has advantages:

Pliant deployment and EU data governance:

  FullPliant binary (single statically-linked executable)
    ↓ no dependency on US cloud SDKs
    ↓ no telemetry, no default external calls
    ↓ audit surface limited to the binary itself

  PostgreSQL (EU-hosted via sota.io)
    ↓ GDPR Article 32: technical security measures
    ↓ all data resident in EU jurisdiction
    ↓ no CLOUD Act exposure (no US-jurisdiction processors)

  HTTP layer (Pliant native server)
    ↓ TLS termination in EU data centre
    ↓ connection logs stored in EU PostgreSQL
    ↓ NIS2 Article 21: security testing of native code via TTCN-3 or similar

A Pliant/FullPliant deployment on EU infrastructure is a data residency guarantee by architecture: no managed US cloud, no dependencies on US-jurisdiction package registries, no runtime calls to external services that might transfer personal data outside GDPR jurisdiction.

Native Compilation: Performance Without a Runtime

Pliant compiles to native machine code. There is no virtual machine, no bytecode interpreter, no JIT warm-up period. A Pliant HTTP server starts in milliseconds and handles requests at native C-equivalent speed.

# Pliant performance characteristics

# Integer arithmetic: compiles to native x86 instructions
function fibonacci n -> result
  arg Int n ; arg_w Int result
  if n <= 1
    result := n
  else
    var Int a b
    fibonacci (n - 1) -> a
    fibonacci (n - 2) -> b
    result := a + b

# Memory: manual or semi-automatic (no GC by default)
# Struct layout: deterministic, no padding surprises
# Function calls: direct native calls (no dispatch overhead)

This matters for deployment: a Pliant application container starts fast, uses predictable memory, and has no GC pause. For a PaaS like sota.io that deploys containers with defined resource limits, native-compiled Pliant behaves like a C or Rust service — consistent, predictable, no warm-up tail latency.

Deploying Pliant on sota.io — EU Infrastructure, Zero DevOps

Pliant compiles to a native binary that runs on any Linux x86-64 host. Containerising a Pliant application for sota.io:

# Pliant application on EU infrastructure
FROM ubuntu:22.04 AS builder

# Install Pliant build dependencies
RUN apt-get update && apt-get install -y \
  build-essential \
  wget \
  && rm -rf /var/lib/apt/lists/*

# Fetch and build Pliant from source
WORKDIR /build
RUN wget https://fullpliant.org/pliant/pliant-source.tar.gz \
  && tar xzf pliant-source.tar.gz \
  && cd pliant && make

# Build application
COPY src/ /app/src/
RUN /build/pliant/pliant /app/src/main.pli -o /app/server

FROM ubuntu:22.04
COPY --from=builder /app/server /app/server
COPY config/ /app/config/

EXPOSE 8080
CMD ["/app/server", "--port", "8080", "--config", "/app/config/server.pli"]

Deploy to EU infrastructure:

# Deploy Pliant application to EU infrastructure
npm install -g sota

# Deploy native Pliant server
sota deploy --name pliant-app --region eu-central-1

# Provision managed PostgreSQL (GDPR-compliant, EU-resident)
sota db create --name pliant-db --region eu-central-1

# Connect app to database
sota env set DATABASE_URL=$(sota db url pliant-db)

# Go
sota deploy
sota logs --follow

PostgreSQL schema for a Pliant web application:

-- EU-resident storage for Pliant/FullPliant applications
CREATE TABLE sessions (
  id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  user_id     INTEGER NOT NULL,
  created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
  expires_at  TIMESTAMPTZ,
  data        JSONB,
  -- GDPR: data residency
  region      VARCHAR(20) DEFAULT 'eu-central-1'
);

CREATE TABLE request_log (
  id          SERIAL PRIMARY KEY,
  path        VARCHAR(500),
  method      VARCHAR(10),
  status      INTEGER,
  duration_ms INTEGER,
  logged_at   TIMESTAMPTZ DEFAULT NOW()
  -- NIS2 Article 21: security audit trail
);

-- No US-jurisdiction processor in the chain
-- PostgreSQL instance: EU data centre (Germany/Netherlands)
-- Pliant binary: statically linked, no external calls

Pliant Today

Pliant and FullPliant remain available as open source (GNU LGPL). The codebase is maintained by Hubert Tonneau 🇫🇷 and a small number of contributors. It is not a mainstream language — the ecosystem is minimal, the documentation sparse, and the community tiny.

But the ideas in Pliant anticipated debates that the broader programming language community would take decades to reach:

The language tree of extensible, self-hosting, native-compiled systems languages now spans decades — from Forth's vocabulary extension in 1970, through Lisp's macros, through Pliant's meta-syntax in France in 1994, to the modern proliferation of compile-time metaprogramming in Rust, Zig, and beyond. Hubert Tonneau 🇫🇷 sat at one of the early nodes of that tree, building a complete web environment from first principles, in France, outside the academic mainstream, before web frameworks were a category.

Extensible compilation lineage:

  Lisp (McCarthy, MIT, 1958) — homoiconic macros
    Forth (Moore, 1970) — user-defined words as language extensions
      Pliant (Tonneau 🇫🇷, 1994) — meta-syntax, native compilation
        FullPliant HTTP server (Tonneau 🇫🇷, ~2000) — self-hosting web stack
  Racket (PLT Group, 1994) — #lang, language-oriented programming
  Rust procedural macros (2018) — compile-time code generation
  Julia @generated functions (2012) — type-dependent code generation

Deploy Pliant on sota.io — EU Infrastructure, GDPR by Default

sota.io is the EU-native PaaS for native applications like Pliant:

# Complete Pliant deployment on sota.io
sota deploy --name pliant-fullpliant --region eu-central-1
sota db create --name pliant-db --region eu-central-1
sota env set DATABASE_URL=$(sota db url pliant-db)
sota logs --follow

Hubert Tonneau 🇫🇷 built FullPliant before most developers had heard of web frameworks — a self-hosting, natively compiled, syntactically extensible environment from France, two decades ahead of the ideas it embodied. Deploy it on European infrastructure, where GDPR compliance is the default and data stays in EU jurisdiction.

Deploy Pliant on EU infrastructure. GDPR-compliant, managed PostgreSQL, zero DevOps.

Pliant was created by Hubert Tonneau 🇫🇷 (France), with development beginning around 1994 and the first public release in 1999. FullPliant — the self-hosting web environment built in Pliant — is available as open source under the GNU LGPL. The language compiles to native x86/x86-64 code on Linux.