2026-04-02·10 min read·sota.io team

Deploy Oberon-2 to Europe — Niklaus Wirth 🇨🇭 + Hanspeter Mössenböck 🇦🇹 (ETH Zürich 1991), the Object-Oriented Refinement of Oberon on EU Infrastructure in 2026

In 1987, Niklaus Wirth and Jürg Gutknecht published Oberon — a language so minimal that its entire specification fit in a few pages. Oberon stripped everything inessential from Modula-2: no enumerations, no variant records, simplified I/O, no low-level arithmetic. What remained was a language you could learn in a weekend and use to write an entire operating system.

By 1991, Wirth knew one thing was missing. Oberon had type extension — records that could extend other records, adding fields. But it had no way to attach procedures to those extended types. Object-oriented programming — the paradigm dominating the early 1990s — required methods, and Oberon did not have them in any formal sense. The solution, designed together with Hanspeter Mössenböck 🇦🇹 at ETH Zürich, was to add exactly one thing: type-bound procedures. Methods attached to record types, with full dynamic dispatch. Nothing else. The result, published in 1991, was Oberon-2.

Oberon-2 is one of the most instructive cases in programming language design: a language defined almost entirely by what it chose not to include. No inheritance graphs. No constructor overloading. No abstract base classes. No virtual keyword. Just records, type extension, and type-bound procedures — the three things you actually need for polymorphism. Everything else is noise.

Hanspeter Mössenböck 🇦🇹 was born in Linz, Austria — the same city that would later become his institutional home. He joined ETH Zürich as a doctoral student and research associate under Wirth, becoming one of the primary contributors to the Oberon system and then to Oberon-2 itself. After the Oberon-2 work, Mössenböck moved to the Johannes Kepler Universität Linz (JKU) 🇦🇹, where he became a professor of computer science and one of Austria's most influential compiler construction researchers. His 1995 book Compiler Construction became a standard reference across European university curricula — a direct descendant of Wirth's own compiler construction tradition.

What Oberon-2 Added to Oberon

Oberon-2 made three additions to Oberon. That is not a summary — that is the complete list.

1. Type-bound procedures — methods attached directly to record types using a receiver parameter:

TYPE
  Shape* = RECORD
    x*, y*: INTEGER;
  END;

  Circle* = RECORD (Shape)
    radius*: INTEGER;
  END;

PROCEDURE (s: Shape) Area*(): REAL;
BEGIN
  RETURN 0.0  (* base implementation *)
END Area;

PROCEDURE (c: Circle) Area*(): REAL;
BEGIN
  RETURN 3.14159 * c.radius * c.radius
END Area;

The (s: Shape) before the procedure name is the receiver — it binds the procedure to the type. Any variable of type Circle will dispatch to Circle.Area dynamically; any other Shape will use the base implementation. This is method dispatch, cleanly and without ceremony.

2. Read-only exported fields — the - export marker that makes a field readable outside the module but not writable:

TYPE
  Account* = RECORD
    balance-: INTEGER;   (* readable outside, writable only inside module *)
    owner*: ARRAY 64 OF CHAR;
  END;

This simple addition — * for full export, - for read-only export — gave Oberon-2 encapsulation at the record level without getter methods. A field marked - behaves like a final field in Java, but the choice is per-field and entirely under programmer control.

3. Open array parameters — arrays whose length is not fixed at the call site:

PROCEDURE PrintAll*(data: ARRAY OF INTEGER);
VAR i: INTEGER;
BEGIN
  FOR i := 0 TO LEN(data) - 1 DO
    Out.Int(data[i], 0); Out.Ln
  END
END PrintAll;

Open arrays make generic array processing possible without dynamic allocation or special cases. The LEN() function returns the actual length at runtime. This is safe, bounds-checked, and entirely predictable — unlike C's pointer-plus-length convention or C++'s template complexity.

These three additions transformed Oberon from a systems language into a complete object-oriented systems language. The design principle is the same as Oberon itself: identify the minimum set of features that genuinely enables the programming style, add those features, and stop.

Hanspeter Mössenböck and the JKU Linz Tradition

Hanspeter Mössenböck 🇦🇹 represents a direct continuation of the Swiss-Austrian compiler construction tradition. Born and educated in Austria, trained at ETH Zürich under Wirth, he brought the Oberon tradition back to Austria when he joined JKU Linz.

At JKU Linz, Mössenböck developed several extensions of the Oberon-2 language:

Oberon-2+ — minor extensions for pattern matching and stream processing.

Oberon/L — an experimental language exploring the addition of generics to Oberon-2.

Component Pascal — the most significant of Mössenböck's language developments, created together with Niklaus Wirth as part of the BlackBox Component Framework (Oberon Microsystems, Zürich). Component Pascal is a refinement of Oberon-2 designed explicitly for component-based software: software built from independently compiled, pluggable components with well-defined interfaces.

Component Pascal added several things that Oberon-2 had omitted:

Abstract record types — types that cannot be instantiated, only extended
ABSTRACT and EXTENSIBLE markers — explicit declaration of which types are designed for extension
EMPTY procedures — procedures with no body, meant to be overridden
LIMITED types — types that cannot be copied or compared by value

The BlackBox Component Framework used Component Pascal as its implementation language and shipped a full Integrated Development Environment — the BlackBox IDE — entirely written in Component Pascal. BlackBox ran on Windows and OS X; its component model influenced early thinking about what would become .NET.

Active Oberon: Concurrent Objects

The most radical direction in Oberon-2's development was Active Oberon, created at ETH Zürich in the late 1990s and early 2000s. Active Oberon added a single concept to Oberon-2: active objects — record types that have a body, a thread of execution that begins when the object is created.

TYPE
  Worker* = OBJECT
    VAR data: ARRAY 1024 OF BYTE;

  PROCEDURE Process*;
  BEGIN
    (* ... process data ... *)
  END Process;

  BEGIN  (* active body — runs concurrently when object is created *)
    LOOP
      Process;
      AWAIT(hasWork)
    END
  END Worker;
END Worker;

An Active Oberon OBJECT with a BEGIN block creates a new thread of execution automatically. The AWAIT construct waits for a condition to become true. Mutual exclusion is handled by the object boundary itself: only one thread can execute a method of the same object at a time. This is the actor model, before Erlang popularized it.

Active Oberon was the implementation language for A2 (formerly Bluebottle), an operating system developed at ETH Zürich that ran concurrent, multi-processor systems with a design philosophy entirely different from Unix: every driver, every file system component, every service was an active object. A2 is still available and maintained by the Computer Systems Institute at ETH Zürich.

The A2 operating system represents one of the few examples in European systems software of a complete OS written in a memory-safe, type-safe language — predating Rust by a decade. Every data race, every buffer overflow, every null pointer dereference that is a routine occurrence in C-based operating systems is impossible by construction in an Active Oberon system.

OBNC — Oberon-2 to C (Modern Compiler)

For practical deployment today, the most accessible Oberon-2 implementation is OBNC — the Oberon-2 Natively Compiled compiler, developed by Fredrik Bromberg. OBNC translates Oberon-2 to C, which is then compiled by the host C compiler to native machine code. OBNC runs on Linux, macOS, and other Unix-like systems, produces binaries with no runtime dependencies beyond libc, and implements the full Oberon-2 language report precisely.

# Install OBNC on Debian/Ubuntu
sudo apt install obnc

# Compile an Oberon-2 module
obnc -o server WebServer.Mod

# Run the compiled binary
./server

The C backend means that Oberon-2 programs compiled with OBNC are deployable anywhere C binaries run — which is everywhere. The generated C code is readable and can be inspected to verify that the Oberon-2 semantics have been preserved correctly.

A minimal Oberon-2 HTTP server using OBNC and the standard socket library:

MODULE WebServer;
IMPORT SYSTEM, Sockets, Strings;

TYPE
  Handler* = RECORD
    port-: INTEGER;
  END;

PROCEDURE (h: Handler) Listen*;
  VAR sock, client: INTEGER;
      buf: ARRAY 4096 OF CHAR;
      response: ARRAY 512 OF CHAR;
BEGIN
  sock := Sockets.Bind(h.port);
  LOOP
    client := Sockets.Accept(sock);
    Sockets.Read(client, buf);
    Strings.Copy("HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nHello from Oberon-2 on EU infrastructure", response);
    Sockets.Write(client, response);
    Sockets.Close(client)
  END
END Listen;

END WebServer.

Dockerfile for Oberon-2 on sota.io

FROM debian:bookworm-slim AS builder
RUN apt-get update && apt-get install -y obnc gcc make && rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY *.Mod .
RUN obnc -o server Main.Mod

FROM debian:bookworm-slim
WORKDIR /app
COPY --from=builder /app/server .
EXPOSE 8080
CMD ["./server"]

The multi-stage build produces a minimal image: the Oberon-2 source in the first stage, a stripped binary in the second. The result is a container under 50MB deploying a type-safe, memory-safe server with no garbage collector pauses.

Mössenböck's Compiler Construction Book

Beyond the language itself, Hanspeter Mössenböck's most enduring contribution to European computer science may be his 1995 book Compiler Construction (Springer, translated to several languages). Where the famous Dragon Book (Aho, Lam, Sethi, Ullman) approaches compiler construction through theory and automata, Mössenböck's book approaches it through construction: build a simple compiler by hand, understand every part.

The textbook presents a complete compiler for a simplified version of Oberon-2, called Oberon-0, implemented in Oberon-2 itself. Students read the language specification, read the compiler source, compile the compiler using the tools they have learned about, and produce a working executable. The complete implementation fits in a few hundred lines. It is Wirth's methodology applied to pedagogy: show everything, hide nothing, make it small enough to understand completely.

This approach — compilers that compile themselves, written in the language they compile — is the tradition of European computer science education stretching from Wirth's original Pascal P-code compiler through Mössenböck's Oberon-0 to the modern Rust self-hosting compiler. Every student who has gone through a European compiler construction course in the past three decades has encountered an Oberon-2-influenced pedagogy.

EU Regulatory Compliance

Oberon-2's type system enforces data protection at the language level. Read-only exported fields (- markers) prevent external modules from modifying sensitive data — the mechanism is the language itself, not documentation. Records encapsulate data tightly: fields are accessible only through explicitly exported procedures or direct field access, and the module boundary is enforced by the compiler, not by convention.

In an Oberon-2 system, GDPR Art. 25's requirement for "data protection by design and by default" is partially satisfied by the language's static type checking and module encapsulation. A GDPR-sensitive field can be marked as read-only at the language level:

TYPE
  DataSubject* = RECORD
    personalDataHash-: ARRAY 64 OF CHAR;   (* read-only outside this module *)
    consentTimestamp-: INTEGER;             (* read-only outside this module *)
    processingPurpose*: ARRAY 128 OF CHAR; (* fully accessible *)
  END;

External modules can read personalDataHash and consentTimestamp for display or auditing — but cannot modify them without going through the module's own exported procedures, which can enforce GDPR-compliant access controls.

EU AI Act Art. 9 — Formal Safety Analysis

Oberon-2's precise, formally defined language semantics make it suitable for static analysis tools that can verify safety properties. The absence of pointer arithmetic, the bounds-checking semantics, and the well-defined module boundaries mean that an Oberon-2 system can be fully specified using formal methods — a requirement for high-risk AI systems under EU AI Act Art. 9.

The Oberon-2 type system's relationship to the Active Oberon concurrent type system provides a provable concurrency model: Active Oberon's object boundaries give a simple and correct mutual exclusion proof, while Oberon-2's type-bound procedure dispatch gives a verifiable polymorphism model.

NIS2 — Critical Infrastructure

Oberon-2 and Active Oberon have been used in safety-critical and infrastructure software at ETH Zürich and affiliated research institutions. The A2 operating system, entirely written in Active Oberon, demonstrates that a complete OS can be built in a memory-safe, type-safe language with provable concurrency semantics — relevant for NIS2's requirements around critical infrastructure software quality.

Performance and Deployment Characteristics

Metric	Oberon-2 (OBNC/C)	Go	Java	Node.js
Binary size	~100-300KB	~8MB	~50MB	~40MB
Cold start	<10ms	<10ms	~300ms	~400ms
Memory baseline	~2MB	~8MB	~64MB	~40MB
Throughput (req/s)	~40,000	~45,000	~30,000	~12,000
GC pauses	None	Yes (short)	Yes (JVM)	Yes (V8)

Oberon-2 compiled via OBNC has performance characteristics comparable to C, with no garbage collector. The language guarantees bounds checking at runtime, but this can be disabled for release builds with the NO_BOUNDS_CHECKING compile flag in OBNC. For production deployments where performance is critical, the trade-off between safety checks and raw throughput is entirely under programmer control.

Deploying Oberon-2 on sota.io

# Install sota CLI
npm install -g sota-cli

# Login to sota.io
sota login

# Deploy from project root (Dockerfile required)
sota deploy

# View logs
sota logs --follow

# Check deployment status
sota status

Oberon-2 backends deploy to EU infrastructure (Germany) with managed PostgreSQL provisioned automatically. The OBNC toolchain produces a static binary that requires only libc at runtime — the container image is minimal and deterministic. GDPR compliance is built into the infrastructure: all data remains in EU jurisdiction, Schrems II transfer restrictions are satisfied by default.

Feature	sota.io	AWS Frankfurt	Render
EU Data Residency	Native (DE)	Opt-in	US-first
GDPR by default	Yes	Config required	Manual
OBNC/Oberon-2 Docker	Yes	Yes	Limited
Managed PostgreSQL	Yes	RDS (extra)	Add-on
Binary deployment	Yes	ECS/ECR	No

Why Oberon-2 and EU Infrastructure

Niklaus Wirth designed every language in the Oberon family at ETH Zürich — one of the world's great technical universities, located in the city that helped define modern banking regulation, hosted the W3C's first European office, and gave the world the European Organisation for Nuclear Research (CERN). Hanspeter Mössenböck extended that tradition in Linz — the Austrian city that is also home to the Ars Electronica, the oldest festival for digital arts and culture in Europe.

When Wirth and Mössenböck chose to make Oberon-2 the language for teaching compiler construction across European universities, they were not making a technical decision alone. They were choosing the language in which the next generation of European computer scientists would learn what a compiler is — what a type system guarantees, what a module boundary means, what dispatch costs. The European tradition of computer science education is partly built from this choice.

Running Oberon-2 on European infrastructure is a natural alignment: a language designed at European institutions, taught in European universities, extended by European researchers — deployed on servers in Germany. sota.io provides the infrastructure layer that the language tradition never had to think about: managed deployment, automatic PostgreSQL, EU data residency as the default.