Deploy Seed7 to Europe — EU-Native General-Purpose Language on EU Infrastructure in 2026
Seed7 is one of the most thoughtfully designed general-purpose languages you have probably never heard of. It was created by Thomas Mertes 🇩🇪🇦🇹 — a German-Austrian developer based in Linz, Austria — who began the project in the 1980s with a clear goal: design a language that is more expressive than C++, safer than Java, and more extensible than either. The result is a statically typed, extensible language that allows programmers to define new syntax constructs, overload operators, and extend the type system at the library level — capabilities that most mainstream languages still lack decades later.
Seed7 compiles to C, which means it runs on any platform where GCC or Clang is available. On EU infrastructure — Hetzner in Germany, OVHcloud in France, Scaleway in France — Seed7 programs compile and run without modification. GDPR compliance is structural: data stays on EU servers by default. For European developers who want a powerful, strongly typed language without the complexity of Rust or the verbosity of Java, Seed7 offers a compelling alternative with deep European roots.
Thomas Mertes — Austrian Engineer, European Language
Thomas Mertes 🇩🇪🇦🇹 is the sole creator and maintainer of Seed7. He began developing the language in the mid-1980s as a research project to explore extensible programming language design — a field where European computer scientists have historically excelled, from Niklaus Wirth 🇨🇭 (Pascal, Modula, Oberon at ETH Zürich) to Guido Rossum 🇳🇱 (Python in Amsterdam) to Bjarne Stroustrup 🇩🇰 (C++ at Bell Labs, Danish-born). Mertes has continued developing and maintaining Seed7 for over three decades — an extraordinary commitment to a language that receives limited mainstream attention but represents serious programming language theory work.
Seed7 is hosted at seed7.sourceforge.net and maintained by Mertes personally. The language has a comprehensive standard library, a working compiler, and detailed documentation that reflects decades of refinement. Mertes's approach mirrors the Austrian and German engineering tradition: rigour over novelty, correctness over marketing, and long-term maintainability over short-term popularity.
The language's name reflects its design philosophy: a seed is the starting point from which growth occurs. Seed7 is designed to be extended — programmers can define new syntax, new operators, and new type constructors that are indistinguishable from built-in language features. This extensibility makes Seed7 a language for language designers as much as application developers.
What Makes Seed7 Distinctive
Extensible Syntax
The defining feature of Seed7 is that its syntax is defined in the language itself. Seed7's syntax declarations allow programmers to introduce new infix operators, new statement forms, and new type constructors as library-level definitions, not compiler extensions. A Seed7 library that defines a new async/await-style concurrency construct is syntactically indistinguishable from a built-in language feature.
$ include "seed7_05.s7i";
include "stdio.s7i";
const proc: main is func
local
var integer: counter is 0;
var string: name is "EU Developer";
begin
writeln("Welcome to Seed7 on EU infrastructure");
for counter range 1 to 5 do
writeln(counter <& ". Hello from " <& name);
end for;
end func;
Strong Static Typing with Type Inference
Seed7 has a stronger type system than most languages commonly described as "strongly typed". All types are checked at compile time. There is no implicit coercion between numeric types — an integer cannot be silently passed where a float is expected. Seed7's var declarations require explicit type annotations, making programs self-documenting.
$ include "seed7_05.s7i";
include "stdio.s7i";
include "float.s7i";
const proc: main is func
local
var integer: count is 0;
var float: ratio is 0.0;
var string: result is "";
begin
count := 42;
ratio := flt(count) / 100.0; # explicit conversion — no implicit coercion
result := str(count) <& " items at " <& str(ratio * 100.0) <& "%";
writeln(result);
end func;
Operator Overloading
Seed7's operator overloading is more systematic than C++'s. Operators are defined as regular functions with const func syntax, and the precedence/associativity are specified in syntax declarations:
$ include "seed7_05.s7i";
include "stdio.s7i";
# Define a 2D vector type
const type: Vector2D is new struct
var float: x is 0.0;
var float: y is 0.0;
end struct;
# Overload + operator for Vector2D
const func Vector2D: (in Vector2D: a) + (in Vector2D: b) is func
result
var Vector2D: sum is Vector2D.value;
begin
sum.x := a.x + b.x;
sum.y := a.y + b.y;
end func;
# Overload * for scalar multiplication
const func Vector2D: (in float: scalar) * (in Vector2D: v) is func
result
var Vector2D: scaled is Vector2D.value;
begin
scaled.x := scalar * v.x;
scaled.y := scalar * v.y;
end func;
const proc: main is func
local
var Vector2D: eu_position is Vector2D.value;
var Vector2D: offset is Vector2D.value;
var Vector2D: result is Vector2D.value;
begin
eu_position.x := 48.8566; # Paris latitude
eu_position.y := 2.3522; # Paris longitude
offset.x := 1.5;
offset.y := 0.3;
result := eu_position + 2.0 * offset;
writeln("Result: " <& result.x <& ", " <& result.y);
end func;
Deploy Seed7 on sota.io
sota.io runs on Hetzner infrastructure in Germany. Data stays in the EU by default. GDPR compliance is structural. Seed7 compiles to C — deploy as a compiled binary in a minimal Docker container.
Prerequisites
- sota.io account (sign up at sota.io)
- Docker installed locally
- Seed7 source code (download from seed7.sourceforge.net)
Step 1 — Seed7 HTTP Server
Seed7's standard library includes basic I/O and socket primitives. For production EU deployments, a common pattern is to compile a Seed7 core service and proxy requests through nginx:
server.s7i — Seed7 HTTP Backend:
$ include "seed7_05.s7i";
include "stdio.s7i";
include "socket.s7i";
include "listener.s7i";
include "time.s7i";
include "duration.s7i";
const integer: PORT is 8080;
const proc: handleRequest (inout file: conn) is func
local
var string: line is "";
var string: method is "";
var string: path is "";
var string: response is "";
begin
line := getln(conn);
if startsWith(line, "GET") then
method := "GET";
path := line[5 .. pred(pos(line, " HTTP"))];
end if;
if path = "/health" then
response := "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n" &
"{\"status\":\"ok\",\"runtime\":\"seed7\",\"region\":\"eu-central\",\"gdpr\":true}";
elsif path = "/api/info" then
response := "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n" &
"{\"language\":\"Seed7\",\"creator\":\"Thomas Mertes\",\"origin\":\"Linz, Austria\",\"eu_hosted\":true}";
else
response := "HTTP/1.1 404 Not Found\r\nContent-Type: application/json\r\n\r\n" &
"{\"error\":\"not found\"}";
end if;
write(conn, response);
close(conn);
end func;
const proc: main is func
local
var listener: server is listener.value;
var file: conn is STD_NULL;
begin
writeln("Seed7 HTTP server starting on port " <& PORT);
server := openInetListener(PORT);
LOOP
conn := openInetAccept(server);
handleRequest(conn);
end LOOP;
end func;
Step 2 — Dockerfile (Seed7 via C compilation)
Seed7 compiles to C, enabling a clean multi-stage Docker build:
# Stage 1: Build Seed7 from source
FROM debian:bookworm-slim AS seed7-builder
RUN apt-get update && apt-get install -y --no-install-recommends \
gcc \
make \
wget \
ca-certificates \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /build
# Download and build Seed7
RUN wget -q https://seed7.sourceforge.net/seed7_2024.tar.gz && \
tar xzf seed7_2024.tar.gz && \
cd seed7_2024/src && \
make
ENV PATH="/build/seed7_2024/bin:$PATH"
# Copy and compile application
COPY server.s7i .
RUN /build/seed7_2024/bin/s7c server.s7i -o server
# Stage 2: Minimal runtime
FROM debian:bookworm-slim
RUN apt-get update && apt-get install -y --no-install-recommends \
libgmp10 \
&& rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY --from=seed7-builder /build/server .
EXPOSE 8080
CMD ["./server"]
Step 3 — GDPR-Aware Seed7 Data Processing
Seed7's strong type system makes GDPR-compliant data handling explicit and auditable. EU personal data types can be defined with built-in retention metadata:
$ include "seed7_05.s7i";
include "stdio.s7i";
include "time.s7i";
# GDPR data subject record — strong typing enforces compliance
const type: EuPersonalData is new struct
var string: subjectId is ""; # pseudonymised — no PII
var string: dataCategory is ""; # GDPR Art. 30 record
var time: collectedAt is time.value;
var time: retentionExpiry is time.value; # HGB §257: max 7 years
var boolean: consentGiven is FALSE;
var string: legalBasis is ""; # Art. 6 GDPR legal basis
var string: dataResidency is "EU"; # always EU on sota.io
end struct;
const func boolean: isRetentionExpired (in EuPersonalData: record) is
return record.retentionExpiry < time(NOW);
const func boolean: canProcess (in EuPersonalData: record) is
return record.consentGiven and not isRetentionExpired(record);
const proc: auditLog (in EuPersonalData: record, in string: action) is func
begin
writeln("[GDPR-AUDIT] " <& action <& " | Subject: " <& record.subjectId <&
" | Basis: " <& record.legalBasis <&
" | Residency: " <& record.dataResidency <&
" | Consent: " <& str(record.consentGiven));
end func;
const proc: main is func
local
var EuPersonalData: subject is EuPersonalData.value;
begin
subject.subjectId := "EU-DE-2024-00142"; # pseudonymised ID
subject.dataCategory := "order_history";
subject.legalBasis := "Art. 6(1)(b) GDPR — contract performance";
subject.consentGiven := TRUE;
subject.dataResidency := "EU-DE"; # Hetzner Falkenstein, Germany
if canProcess(subject) then
auditLog(subject, "PROCESS");
writeln("Processing permitted: legal basis confirmed, consent active, EU-resident data");
else
auditLog(subject, "BLOCKED");
writeln("Processing blocked: consent withdrawn or retention period expired");
end if;
end func;
Step 4 — sota.sh deploy config
#!/bin/bash
# sota.sh — Deploy Seed7 server to EU infrastructure
sota deploy \
--name seed7-backend \
--region eu-central \
--db postgres
$ sota deploy
▸ Building Docker image (multi-stage: Seed7 → C → binary)...
▸ Pushing to EU registry (Frankfurt)...
▸ Deploying to Hetzner (Falkenstein, Germany)...
✓ seed7-backend deployed — https://seed7-backend.sota.run
✓ PostgreSQL provisioned (EU, Germany)
✓ GDPR data residency: confirmed EU
European Language Design Heritage
Seed7 belongs to a distinguished tradition of European programming language design that prioritises correctness and expressiveness over pragmatic adoption:
- Niklaus Wirth 🇨🇭 (ETH Zürich) — Pascal (1970), Modula-2 (1978), Oberon (1987): Swiss precision in language design, each language a refinement of the last
- Guido van Rossum 🇳🇱 (CWI Amsterdam) — Python (1991): Dutch pragmatism, readability as a core design principle
- Bjarne Stroustrup 🇩🇰 (Bell Labs, Danish-born) — C++ (1985): Danish rigour applied to systems programming
- Martin Odersky 🇩🇪 (EPFL Lausanne, German) — Scala (2004): academic rigour meeting JVM pragmatism
- Lars Bak 🇩🇰 (Danish) — V8 JavaScript engine (Google), Dart co-creator
- Thomas Mertes 🇩🇪🇦🇹 (German-Austrian, Linz) — Seed7: extensibility as a first-class language feature
This lineage reflects a European approach to computing: languages designed to be provably correct rather than merely practically useful, with long design cycles and deep theoretical grounding. Seed7's three-decade development timeline is consistent with this tradition — Wirth's work on Pascal to Oberon spanned two decades; Mertes's commitment to Seed7 is comparable.
EU Regulatory Alignment
Seed7's type system naturally maps to EU regulatory requirements:
GDPR (General Data Protection Regulation): Seed7's strong static typing makes it impossible to accidentally pass personal data where non-personal data is expected — if you define a PersonalData type, only PersonalData values can be assigned to PersonalData variables. This compile-time enforcement of data classification is a natural fit for GDPR Article 25 (data protection by design and by default).
EU AI Act: Seed7's transparency — every program compiles to readable C code — supports the EU AI Act's requirements for explainability and auditability of automated systems. Seed7 programs have no hidden runtime magic: the compiled C output is auditable by any competent developer.
NIS2 Directive: Seed7's memory safety characteristics (no pointer arithmetic, bounds-checked arrays) reduce the attack surface for EU critical infrastructure applications subject to NIS2's cybersecurity requirements.
sota.io + Seed7: EU Infrastructure for EU Languages
Seed7 was designed by a European engineer for correctness and expressiveness. sota.io provides the EU hosting layer that keeps Seed7 applications' data in Europe where it belongs. The stack is clean: Seed7 → compiled C binary → Docker → Hetzner Germany → GDPR-compliant by default.
For European developers exploring type-safe systems programming without Rust's complexity, or seeking a language with genuine extensibility beyond what TypeScript or Python offer, Seed7 presents a seriously engineered alternative with deep European roots and a 30-year track record.